github.com/aliyun/aliyun-oss-go-sdk@v3.0.2+incompatible/sample/The Go Programming Language.html (about)

     1  <!DOCTYPE html>
     2  <!-- saved from url=(0032)https://golang.org/pkg/net/http/ -->
     3  <html><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
     4  
     5  <meta name="viewport" content="width=device-width, initial-scale=1">
     6  <meta name="theme-color" content="#375EAB">
     7  
     8    <title>http - The Go Programming Language</title>
     9  
    10  <link type="text/css" rel="stylesheet" href="./http - The Go Programming Language_files/style.css">
    11  
    12  <link rel="search" type="application/opensearchdescription+xml" title="godoc" href="https://golang.org/opensearch.xml">
    13  
    14  <link rel="stylesheet" href="./http - The Go Programming Language_files/jquery.treeview.css">
    15  <script type="text/javascript" async="" src="./http - The Go Programming Language_files/ga.js"></script><script type="text/javascript">window.initFuncs = [];</script>
    16  <script type="text/javascript">
    17  var _gaq = _gaq || [];
    18  _gaq.push(["_setAccount", "UA-11222381-2"]);
    19  _gaq.push(["b._setAccount", "UA-49880327-6"]);
    20  window.trackPageview = function() {
    21    _gaq.push(["_trackPageview", location.pathname+location.hash]);
    22    _gaq.push(["b._trackPageview", location.pathname+location.hash]);
    23  };
    24  window.trackPageview();
    25  window.trackEvent = function(category, action, opt_label, opt_value, opt_noninteraction) {
    26    _gaq.push(["_trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
    27    _gaq.push(["b._trackEvent", category, action, opt_label, opt_value, opt_noninteraction]);
    28  };
    29  </script>
    30  </head>
    31  <body>
    32  
    33  <div id="lowframe" style="position: fixed; bottom: 0; left: 0; height: 0; width: 100%; border-top: thin solid grey; background-color: white; overflow: auto;">
    34  ...
    35  </div><!-- #lowframe -->
    36  
    37  <div id="topbar" class="wide"><div class="container">
    38  <div class="top-heading" id="heading-wide"><a href="https://golang.org/">The Go Programming Language</a></div>
    39  <div class="top-heading" id="heading-narrow"><a href="https://golang.org/">Go</a></div>
    40  <a href="https://golang.org/pkg/net/http/#" id="menu-button"><span id="menu-button-arrow">▽</span></a>
    41  <form method="GET" action="https://golang.org/search">
    42  <div id="menu" style="min-width: 60px;">
    43  <a href="https://golang.org/doc/">Documents</a>
    44  <a href="https://golang.org/pkg/">Packages</a>
    45  <a href="https://golang.org/project/">The Project</a>
    46  <a href="https://golang.org/help/">Help</a>
    47  <a href="https://golang.org/blog/">Blog</a>
    48  
    49  <a id="playgroundButton" href="http://play.golang.org/" title="Show Go Playground" style="display: inline;">Play</a>
    50  
    51  <input type="text" id="search" name="q" class="inactive" value="Search" placeholder="Search">
    52  </div>
    53  </form>
    54  
    55  </div></div>
    56  
    57  
    58  <div id="playground" class="play">
    59  	<div class="input"><textarea class="code">package main
    60  
    61  import "fmt"
    62  
    63  func main() {
    64  	fmt.Println("Hello, 世界")
    65  }</textarea></div>
    66  	<div class="output"></div>
    67  	<div class="buttons">
    68  		<a class="run" title="Run this code [shift-enter]">Run</a>
    69  		<a class="fmt" title="Format this code">Format</a>
    70  		
    71  	</div>
    72  </div>
    73  
    74  
    75  <div id="page" class="wide" tabindex="-1" style="outline: 0px;">
    76  <div class="container">
    77  
    78  
    79    <h1>Package http</h1>
    80  
    81  
    82  
    83  
    84  <div id="nav"></div>
    85  
    86  
    87  <!--
    88  	Copyright 2009 The Go Authors. All rights reserved.
    89  	Use of this source code is governed by a BSD-style
    90  	license that can be found in the LICENSE file.
    91  -->
    92  <!--
    93  	Note: Static (i.e., not template-generated) href and id
    94  	attributes start with "pkg-" to make it impossible for
    95  	them to conflict with generated attributes (some of which
    96  	correspond to Go identifiers).
    97  -->
    98  
    99  	<script type="text/javascript">
   100  	document.ANALYSIS_DATA = null;
   101  	document.CALLGRAPH = null;
   102  	</script>
   103  
   104  	
   105  		
   106  		<div id="short-nav">
   107  			<dl>
   108  			<dd><code>import "net/http"</code></dd>
   109  			</dl>
   110  			<dl>
   111  			<dd><a href="https://golang.org/pkg/net/http/#pkg-overview" class="overviewLink">Overview</a></dd>
   112  			<dd><a href="https://golang.org/pkg/net/http/#pkg-index" class="indexLink">Index</a></dd>
   113  			
   114  				<dd><a href="https://golang.org/pkg/net/http/#pkg-examples" class="examplesLink">Examples</a></dd>
   115  			
   116  			
   117  				<dd><a href="https://golang.org/pkg/net/http/#pkg-subdirectories">Subdirectories</a></dd>
   118  			
   119  			</dl>
   120  		</div>
   121  		<!-- The package's Name is printed as title by the top-level template -->
   122  		<div id="pkg-overview" class="toggleVisible">
   123  			<div class="collapsed">
   124  				<h2 class="toggleButton" title="Click to show Overview section">Overview ▹</h2>
   125  			</div>
   126  			<div class="expanded">
   127  				<h2 class="toggleButton" title="Click to hide Overview section">Overview ▾</h2>
   128  				<p>
   129  Package http provides HTTP client and server implementations.
   130  </p>
   131  <p>
   132  Get, Head, Post, and PostForm make HTTP (or HTTPS) requests:
   133  </p>
   134  <pre>resp, err := http.Get("<a href="http://example.com/">http://example.com/</a>")
   135  ...
   136  resp, err := http.Post("<a href="http://example.com/upload">http://example.com/upload</a>", "image/jpeg", &amp;buf)
   137  ...
   138  resp, err := http.PostForm("<a href="http://example.com/form">http://example.com/form</a>",
   139  	url.Values{"key": {"Value"}, "id": {"123"}})
   140  </pre>
   141  <p>
   142  The client must close the response body when finished with it:
   143  </p>
   144  <pre>resp, err := http.Get("<a href="http://example.com/">http://example.com/</a>")
   145  if err != nil {
   146  	// handle error
   147  }
   148  defer resp.Body.Close()
   149  body, err := ioutil.ReadAll(resp.Body)
   150  // ...
   151  </pre>
   152  <p>
   153  For control over HTTP client headers, redirect policy, and other
   154  settings, create a Client:
   155  </p>
   156  <pre>client := &amp;http.Client{
   157  	CheckRedirect: redirectPolicyFunc,
   158  }
   159  
   160  resp, err := client.Get("<a href="http://example.com/">http://example.com</a>")
   161  // ...
   162  
   163  req, err := http.NewRequest("GET", "<a href="http://example.com/">http://example.com</a>", nil)
   164  // ...
   165  req.Header.Add("If-None-Match", `W/"wyzzy"`)
   166  resp, err := client.Do(req)
   167  // ...
   168  </pre>
   169  <p>
   170  For control over proxies, TLS configuration, keep-alives,
   171  compression, and other settings, create a Transport:
   172  </p>
   173  <pre>tr := &amp;http.Transport{
   174  	TLSClientConfig:    &amp;tls.Config{RootCAs: pool},
   175  	DisableCompression: true,
   176  }
   177  client := &amp;http.Client{Transport: tr}
   178  resp, err := client.Get("<a href="https://example.com/">https://example.com</a>")
   179  </pre>
   180  <p>
   181  Clients and Transports are safe for concurrent use by multiple
   182  goroutines and for efficiency should only be created once and re-used.
   183  </p>
   184  <p>
   185  ListenAndServe starts an HTTP server with a given address and handler.
   186  The handler is usually nil, which means to use DefaultServeMux.
   187  Handle and HandleFunc add handlers to DefaultServeMux:
   188  </p>
   189  <pre>http.Handle("/foo", fooHandler)
   190  
   191  http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
   192  	fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
   193  })
   194  
   195  log.Fatal(http.ListenAndServe(":8080", nil))
   196  </pre>
   197  <p>
   198  More control over the server's behavior is available by creating a
   199  custom Server:
   200  </p>
   201  <pre>s := &amp;http.Server{
   202  	Addr:           ":8080",
   203  	Handler:        myHandler,
   204  	ReadTimeout:    10 * time.Second,
   205  	WriteTimeout:   10 * time.Second,
   206  	MaxHeaderBytes: 1 &lt;&lt; 20,
   207  }
   208  log.Fatal(s.ListenAndServe())
   209  </pre>
   210  
   211  			</div>
   212  		</div>
   213  		
   214  
   215  		<div id="pkg-index" class="toggleVisible">
   216  		<div class="collapsed">
   217  			<h2 class="toggleButton" title="Click to show Index section">Index ▹</h2>
   218  		</div>
   219  		<div class="expanded">
   220  			<h2 class="toggleButton" title="Click to hide Index section">Index ▾</h2>
   221  
   222  		<!-- Table of contents for API; must be named manual-nav to turn off auto nav. -->
   223  			<div id="manual-nav">
   224  			<dl>
   225  			
   226  				<dd><a href="https://golang.org/pkg/net/http/#pkg-constants">Constants</a></dd>
   227  			
   228  			
   229  				<dd><a href="https://golang.org/pkg/net/http/#pkg-variables">Variables</a></dd>
   230  			
   231  			
   232  				
   233  				<dd><a href="https://golang.org/pkg/net/http/#CanonicalHeaderKey">func CanonicalHeaderKey(s string) string</a></dd>
   234  			
   235  				
   236  				<dd><a href="https://golang.org/pkg/net/http/#DetectContentType">func DetectContentType(data []byte) string</a></dd>
   237  			
   238  				
   239  				<dd><a href="https://golang.org/pkg/net/http/#Error">func Error(w ResponseWriter, error string, code int)</a></dd>
   240  			
   241  				
   242  				<dd><a href="https://golang.org/pkg/net/http/#Handle">func Handle(pattern string, handler Handler)</a></dd>
   243  			
   244  				
   245  				<dd><a href="https://golang.org/pkg/net/http/#HandleFunc">func HandleFunc(pattern string, handler func(ResponseWriter, *Request))</a></dd>
   246  			
   247  				
   248  				<dd><a href="https://golang.org/pkg/net/http/#ListenAndServe">func ListenAndServe(addr string, handler Handler) error</a></dd>
   249  			
   250  				
   251  				<dd><a href="https://golang.org/pkg/net/http/#ListenAndServeTLS">func ListenAndServeTLS(addr string, certFile string, keyFile string, handler Handler) error</a></dd>
   252  			
   253  				
   254  				<dd><a href="https://golang.org/pkg/net/http/#MaxBytesReader">func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser</a></dd>
   255  			
   256  				
   257  				<dd><a href="https://golang.org/pkg/net/http/#NotFound">func NotFound(w ResponseWriter, r *Request)</a></dd>
   258  			
   259  				
   260  				<dd><a href="https://golang.org/pkg/net/http/#ParseHTTPVersion">func ParseHTTPVersion(vers string) (major, minor int, ok bool)</a></dd>
   261  			
   262  				
   263  				<dd><a href="https://golang.org/pkg/net/http/#ParseTime">func ParseTime(text string) (t time.Time, err error)</a></dd>
   264  			
   265  				
   266  				<dd><a href="https://golang.org/pkg/net/http/#ProxyFromEnvironment">func ProxyFromEnvironment(req *Request) (*url.URL, error)</a></dd>
   267  			
   268  				
   269  				<dd><a href="https://golang.org/pkg/net/http/#ProxyURL">func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)</a></dd>
   270  			
   271  				
   272  				<dd><a href="https://golang.org/pkg/net/http/#Redirect">func Redirect(w ResponseWriter, r *Request, urlStr string, code int)</a></dd>
   273  			
   274  				
   275  				<dd><a href="https://golang.org/pkg/net/http/#Serve">func Serve(l net.Listener, handler Handler) error</a></dd>
   276  			
   277  				
   278  				<dd><a href="https://golang.org/pkg/net/http/#ServeContent">func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)</a></dd>
   279  			
   280  				
   281  				<dd><a href="https://golang.org/pkg/net/http/#ServeFile">func ServeFile(w ResponseWriter, r *Request, name string)</a></dd>
   282  			
   283  				
   284  				<dd><a href="https://golang.org/pkg/net/http/#SetCookie">func SetCookie(w ResponseWriter, cookie *Cookie)</a></dd>
   285  			
   286  				
   287  				<dd><a href="https://golang.org/pkg/net/http/#StatusText">func StatusText(code int) string</a></dd>
   288  			
   289  			
   290  				
   291  				<dd><a href="https://golang.org/pkg/net/http/#Client">type Client</a></dd>
   292  				
   293  				
   294  					
   295  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Client.Do">func (c *Client) Do(req *Request) (resp *Response, err error)</a></dd>
   296  				
   297  					
   298  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Client.Get">func (c *Client) Get(url string) (resp *Response, err error)</a></dd>
   299  				
   300  					
   301  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Client.Head">func (c *Client) Head(url string) (resp *Response, err error)</a></dd>
   302  				
   303  					
   304  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Client.Post">func (c *Client) Post(url string, bodyType string, body io.Reader) (resp *Response, err error)</a></dd>
   305  				
   306  					
   307  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Client.PostForm">func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error)</a></dd>
   308  				
   309  			
   310  				
   311  				<dd><a href="https://golang.org/pkg/net/http/#CloseNotifier">type CloseNotifier</a></dd>
   312  				
   313  				
   314  			
   315  				
   316  				<dd><a href="https://golang.org/pkg/net/http/#ConnState">type ConnState</a></dd>
   317  				
   318  				
   319  					
   320  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ConnState.String">func (c ConnState) String() string</a></dd>
   321  				
   322  			
   323  				
   324  				<dd><a href="https://golang.org/pkg/net/http/#Cookie">type Cookie</a></dd>
   325  				
   326  				
   327  					
   328  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Cookie.String">func (c *Cookie) String() string</a></dd>
   329  				
   330  			
   331  				
   332  				<dd><a href="https://golang.org/pkg/net/http/#CookieJar">type CookieJar</a></dd>
   333  				
   334  				
   335  			
   336  				
   337  				<dd><a href="https://golang.org/pkg/net/http/#Dir">type Dir</a></dd>
   338  				
   339  				
   340  					
   341  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Dir.Open">func (d Dir) Open(name string) (File, error)</a></dd>
   342  				
   343  			
   344  				
   345  				<dd><a href="https://golang.org/pkg/net/http/#File">type File</a></dd>
   346  				
   347  				
   348  			
   349  				
   350  				<dd><a href="https://golang.org/pkg/net/http/#FileSystem">type FileSystem</a></dd>
   351  				
   352  				
   353  			
   354  				
   355  				<dd><a href="https://golang.org/pkg/net/http/#Flusher">type Flusher</a></dd>
   356  				
   357  				
   358  			
   359  				
   360  				<dd><a href="https://golang.org/pkg/net/http/#Handler">type Handler</a></dd>
   361  				
   362  					
   363  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#FileServer">func FileServer(root FileSystem) Handler</a></dd>
   364  				
   365  					
   366  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#NotFoundHandler">func NotFoundHandler() Handler</a></dd>
   367  				
   368  					
   369  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#RedirectHandler">func RedirectHandler(url string, code int) Handler</a></dd>
   370  				
   371  					
   372  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#StripPrefix">func StripPrefix(prefix string, h Handler) Handler</a></dd>
   373  				
   374  					
   375  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#TimeoutHandler">func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler</a></dd>
   376  				
   377  				
   378  			
   379  				
   380  				<dd><a href="https://golang.org/pkg/net/http/#HandlerFunc">type HandlerFunc</a></dd>
   381  				
   382  				
   383  					
   384  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#HandlerFunc.ServeHTTP">func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)</a></dd>
   385  				
   386  			
   387  				
   388  				<dd><a href="https://golang.org/pkg/net/http/#Header">type Header</a></dd>
   389  				
   390  				
   391  					
   392  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.Add">func (h Header) Add(key, value string)</a></dd>
   393  				
   394  					
   395  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.Del">func (h Header) Del(key string)</a></dd>
   396  				
   397  					
   398  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.Get">func (h Header) Get(key string) string</a></dd>
   399  				
   400  					
   401  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.Set">func (h Header) Set(key, value string)</a></dd>
   402  				
   403  					
   404  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.Write">func (h Header) Write(w io.Writer) error</a></dd>
   405  				
   406  					
   407  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Header.WriteSubset">func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error</a></dd>
   408  				
   409  			
   410  				
   411  				<dd><a href="https://golang.org/pkg/net/http/#Hijacker">type Hijacker</a></dd>
   412  				
   413  				
   414  			
   415  				
   416  				<dd><a href="https://golang.org/pkg/net/http/#ProtocolError">type ProtocolError</a></dd>
   417  				
   418  				
   419  					
   420  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ProtocolError.Error">func (err *ProtocolError) Error() string</a></dd>
   421  				
   422  			
   423  				
   424  				<dd><a href="https://golang.org/pkg/net/http/#Request">type Request</a></dd>
   425  				
   426  					
   427  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#NewRequest">func NewRequest(method, urlStr string, body io.Reader) (*Request, error)</a></dd>
   428  				
   429  					
   430  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ReadRequest">func ReadRequest(b *bufio.Reader) (req *Request, err error)</a></dd>
   431  				
   432  				
   433  					
   434  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.AddCookie">func (r *Request) AddCookie(c *Cookie)</a></dd>
   435  				
   436  					
   437  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.BasicAuth">func (r *Request) BasicAuth() (username, password string, ok bool)</a></dd>
   438  				
   439  					
   440  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.Cookie">func (r *Request) Cookie(name string) (*Cookie, error)</a></dd>
   441  				
   442  					
   443  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.Cookies">func (r *Request) Cookies() []*Cookie</a></dd>
   444  				
   445  					
   446  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.FormFile">func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)</a></dd>
   447  				
   448  					
   449  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.FormValue">func (r *Request) FormValue(key string) string</a></dd>
   450  				
   451  					
   452  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.MultipartReader">func (r *Request) MultipartReader() (*multipart.Reader, error)</a></dd>
   453  				
   454  					
   455  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.ParseForm">func (r *Request) ParseForm() error</a></dd>
   456  				
   457  					
   458  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.ParseMultipartForm">func (r *Request) ParseMultipartForm(maxMemory int64) error</a></dd>
   459  				
   460  					
   461  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.PostFormValue">func (r *Request) PostFormValue(key string) string</a></dd>
   462  				
   463  					
   464  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.ProtoAtLeast">func (r *Request) ProtoAtLeast(major, minor int) bool</a></dd>
   465  				
   466  					
   467  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.Referer">func (r *Request) Referer() string</a></dd>
   468  				
   469  					
   470  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.SetBasicAuth">func (r *Request) SetBasicAuth(username, password string)</a></dd>
   471  				
   472  					
   473  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.UserAgent">func (r *Request) UserAgent() string</a></dd>
   474  				
   475  					
   476  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.Write">func (r *Request) Write(w io.Writer) error</a></dd>
   477  				
   478  					
   479  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Request.WriteProxy">func (r *Request) WriteProxy(w io.Writer) error</a></dd>
   480  				
   481  			
   482  				
   483  				<dd><a href="https://golang.org/pkg/net/http/#Response">type Response</a></dd>
   484  				
   485  					
   486  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Get">func Get(url string) (resp *Response, err error)</a></dd>
   487  				
   488  					
   489  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Head">func Head(url string) (resp *Response, err error)</a></dd>
   490  				
   491  					
   492  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Post">func Post(url string, bodyType string, body io.Reader) (resp *Response, err error)</a></dd>
   493  				
   494  					
   495  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#PostForm">func PostForm(url string, data url.Values) (resp *Response, err error)</a></dd>
   496  				
   497  					
   498  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ReadResponse">func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)</a></dd>
   499  				
   500  				
   501  					
   502  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Response.Cookies">func (r *Response) Cookies() []*Cookie</a></dd>
   503  				
   504  					
   505  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Response.Location">func (r *Response) Location() (*url.URL, error)</a></dd>
   506  				
   507  					
   508  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Response.ProtoAtLeast">func (r *Response) ProtoAtLeast(major, minor int) bool</a></dd>
   509  				
   510  					
   511  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Response.Write">func (r *Response) Write(w io.Writer) error</a></dd>
   512  				
   513  			
   514  				
   515  				<dd><a href="https://golang.org/pkg/net/http/#ResponseWriter">type ResponseWriter</a></dd>
   516  				
   517  				
   518  			
   519  				
   520  				<dd><a href="https://golang.org/pkg/net/http/#RoundTripper">type RoundTripper</a></dd>
   521  				
   522  					
   523  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#NewFileTransport">func NewFileTransport(fs FileSystem) RoundTripper</a></dd>
   524  				
   525  				
   526  			
   527  				
   528  				<dd><a href="https://golang.org/pkg/net/http/#ServeMux">type ServeMux</a></dd>
   529  				
   530  					
   531  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#NewServeMux">func NewServeMux() *ServeMux</a></dd>
   532  				
   533  				
   534  					
   535  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ServeMux.Handle">func (mux *ServeMux) Handle(pattern string, handler Handler)</a></dd>
   536  				
   537  					
   538  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ServeMux.HandleFunc">func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))</a></dd>
   539  				
   540  					
   541  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ServeMux.Handler">func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)</a></dd>
   542  				
   543  					
   544  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#ServeMux.ServeHTTP">func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)</a></dd>
   545  				
   546  			
   547  				
   548  				<dd><a href="https://golang.org/pkg/net/http/#Server">type Server</a></dd>
   549  				
   550  				
   551  					
   552  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Server.ListenAndServe">func (srv *Server) ListenAndServe() error</a></dd>
   553  				
   554  					
   555  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Server.ListenAndServeTLS">func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error</a></dd>
   556  				
   557  					
   558  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Server.Serve">func (srv *Server) Serve(l net.Listener) error</a></dd>
   559  				
   560  					
   561  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Server.SetKeepAlivesEnabled">func (srv *Server) SetKeepAlivesEnabled(v bool)</a></dd>
   562  				
   563  			
   564  				
   565  				<dd><a href="https://golang.org/pkg/net/http/#Transport">type Transport</a></dd>
   566  				
   567  				
   568  					
   569  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Transport.CancelRequest">func (t *Transport) CancelRequest(req *Request)</a></dd>
   570  				
   571  					
   572  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Transport.CloseIdleConnections">func (t *Transport) CloseIdleConnections()</a></dd>
   573  				
   574  					
   575  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Transport.RegisterProtocol">func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper)</a></dd>
   576  				
   577  					
   578  					<dd>&nbsp; &nbsp; <a href="https://golang.org/pkg/net/http/#Transport.RoundTrip">func (t *Transport) RoundTrip(req *Request) (resp *Response, err error)</a></dd>
   579  				
   580  			
   581  			
   582  			</dl>
   583  			</div><!-- #manual-nav -->
   584  
   585  		
   586  		<div id="pkg-examples">
   587  			<h4>Examples</h4>
   588  			<dl>
   589  			
   590  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_FileServer">FileServer</a></dd>
   591  			
   592  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_FileServer_stripPrefix">FileServer (StripPrefix)</a></dd>
   593  			
   594  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_Get">Get</a></dd>
   595  			
   596  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_Hijacker">Hijacker</a></dd>
   597  			
   598  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_ResponseWriter_trailers">ResponseWriter (Trailers)</a></dd>
   599  			
   600  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_ServeMux_Handle">ServeMux.Handle</a></dd>
   601  			
   602  			<dd><a class="exampleLink" href="https://golang.org/pkg/net/http/#example_StripPrefix">StripPrefix</a></dd>
   603  			
   604  			</dl>
   605  		</div>
   606  		
   607  
   608  		
   609  			<h4>Package files</h4>
   610  			<p>
   611  			<span style="font-size:90%">
   612  			
   613  				<a href="https://golang.org/src/net/http/client.go">client.go</a>
   614  			
   615  				<a href="https://golang.org/src/net/http/cookie.go">cookie.go</a>
   616  			
   617  				<a href="https://golang.org/src/net/http/doc.go">doc.go</a>
   618  			
   619  				<a href="https://golang.org/src/net/http/filetransport.go">filetransport.go</a>
   620  			
   621  				<a href="https://golang.org/src/net/http/fs.go">fs.go</a>
   622  			
   623  				<a href="https://golang.org/src/net/http/header.go">header.go</a>
   624  			
   625  				<a href="https://golang.org/src/net/http/jar.go">jar.go</a>
   626  			
   627  				<a href="https://golang.org/src/net/http/lex.go">lex.go</a>
   628  			
   629  				<a href="https://golang.org/src/net/http/request.go">request.go</a>
   630  			
   631  				<a href="https://golang.org/src/net/http/response.go">response.go</a>
   632  			
   633  				<a href="https://golang.org/src/net/http/server.go">server.go</a>
   634  			
   635  				<a href="https://golang.org/src/net/http/sniff.go">sniff.go</a>
   636  			
   637  				<a href="https://golang.org/src/net/http/status.go">status.go</a>
   638  			
   639  				<a href="https://golang.org/src/net/http/transfer.go">transfer.go</a>
   640  			
   641  				<a href="https://golang.org/src/net/http/transport.go">transport.go</a>
   642  			
   643  			</span>
   644  			</p>
   645  		
   646  		</div><!-- .expanded -->
   647  		</div><!-- #pkg-index -->
   648  
   649  		<div id="pkg-callgraph" class="toggle" style="display: none">
   650  		<div class="collapsed">
   651  			<h2 class="toggleButton" title="Click to show Internal Call Graph section">Internal call graph ▹</h2>
   652  		</div> <!-- .expanded -->
   653  		<div class="expanded">
   654  			<h2 class="toggleButton" title="Click to hide Internal Call Graph section">Internal call graph ▾</h2>
   655  			<p>
   656  			  In the call graph viewer below, each node
   657  			  is a function belonging to this package
   658  			  and its children are the functions it
   659  			  calls—perhaps dynamically.
   660  			</p>
   661  			<p>
   662  			  The root nodes are the entry points of the
   663  			  package: functions that may be called from
   664  			  outside the package.
   665  			  There may be non-exported or anonymous
   666  			  functions among them if they are called
   667  			  dynamically from another package.
   668  			</p>
   669  			<p>
   670  			  Click a node to visit that function's source code.
   671  			  From there you can visit its callers by
   672  			  clicking its declaring <code>func</code>
   673  			  token.
   674  			</p>
   675  			<p>
   676  			  Functions may be omitted if they were
   677  			  determined to be unreachable in the
   678  			  particular programs or tests that were
   679  			  analyzed.
   680  			</p>
   681  			<!-- Zero means show all package entry points. -->
   682  			<ul style="margin-left: 0.5in" id="callgraph-0" class="treeview"></ul>
   683  		</div>
   684  		</div> <!-- #pkg-callgraph -->
   685  
   686  		
   687  			<h2 id="pkg-constants">Constants</h2>
   688  			
   689  				<pre>const (
   690          <span id="StatusContinue">StatusContinue</span>           = 100
   691          <span id="StatusSwitchingProtocols">StatusSwitchingProtocols</span> = 101
   692  
   693          <span id="StatusOK">StatusOK</span>                   = 200
   694          <span id="StatusCreated">StatusCreated</span>              = 201
   695          <span id="StatusAccepted">StatusAccepted</span>             = 202
   696          <span id="StatusNonAuthoritativeInfo">StatusNonAuthoritativeInfo</span> = 203
   697          <span id="StatusNoContent">StatusNoContent</span>            = 204
   698          <span id="StatusResetContent">StatusResetContent</span>         = 205
   699          <span id="StatusPartialContent">StatusPartialContent</span>       = 206
   700  
   701          <span id="StatusMultipleChoices">StatusMultipleChoices</span>   = 300
   702          <span id="StatusMovedPermanently">StatusMovedPermanently</span>  = 301
   703          <span id="StatusFound">StatusFound</span>             = 302
   704          <span id="StatusSeeOther">StatusSeeOther</span>          = 303
   705          <span id="StatusNotModified">StatusNotModified</span>       = 304
   706          <span id="StatusUseProxy">StatusUseProxy</span>          = 305
   707          <span id="StatusTemporaryRedirect">StatusTemporaryRedirect</span> = 307
   708  
   709          <span id="StatusBadRequest">StatusBadRequest</span>                   = 400
   710          <span id="StatusUnauthorized">StatusUnauthorized</span>                 = 401
   711          <span id="StatusPaymentRequired">StatusPaymentRequired</span>              = 402
   712          <span id="StatusForbidden">StatusForbidden</span>                    = 403
   713          <span id="StatusNotFound">StatusNotFound</span>                     = 404
   714          <span id="StatusMethodNotAllowed">StatusMethodNotAllowed</span>             = 405
   715          <span id="StatusNotAcceptable">StatusNotAcceptable</span>                = 406
   716          <span id="StatusProxyAuthRequired">StatusProxyAuthRequired</span>            = 407
   717          <span id="StatusRequestTimeout">StatusRequestTimeout</span>               = 408
   718          <span id="StatusConflict">StatusConflict</span>                     = 409
   719          <span id="StatusGone">StatusGone</span>                         = 410
   720          <span id="StatusLengthRequired">StatusLengthRequired</span>               = 411
   721          <span id="StatusPreconditionFailed">StatusPreconditionFailed</span>           = 412
   722          <span id="StatusRequestEntityTooLarge">StatusRequestEntityTooLarge</span>        = 413
   723          <span id="StatusRequestURITooLong">StatusRequestURITooLong</span>            = 414
   724          <span id="StatusUnsupportedMediaType">StatusUnsupportedMediaType</span>         = 415
   725          <span id="StatusRequestedRangeNotSatisfiable">StatusRequestedRangeNotSatisfiable</span> = 416
   726          <span id="StatusExpectationFailed">StatusExpectationFailed</span>            = 417
   727          <span id="StatusTeapot">StatusTeapot</span>                       = 418
   728  
   729          <span id="StatusInternalServerError">StatusInternalServerError</span>     = 500
   730          <span id="StatusNotImplemented">StatusNotImplemented</span>          = 501
   731          <span id="StatusBadGateway">StatusBadGateway</span>              = 502
   732          <span id="StatusServiceUnavailable">StatusServiceUnavailable</span>      = 503
   733          <span id="StatusGatewayTimeout">StatusGatewayTimeout</span>          = 504
   734          <span id="StatusHTTPVersionNotSupported">StatusHTTPVersionNotSupported</span> = 505
   735  )</pre>
   736  				<p>
   737  HTTP status codes, defined in RFC 2616.
   738  </p>
   739  
   740  			
   741  				<pre>const <span id="DefaultMaxHeaderBytes">DefaultMaxHeaderBytes</span> = 1 &lt;&lt; 20 <span class="comment">// 1 MB</span>
   742  </pre>
   743  				<p>
   744  DefaultMaxHeaderBytes is the maximum permitted size of the headers
   745  in an HTTP request.
   746  This can be overridden by setting Server.MaxHeaderBytes.
   747  </p>
   748  
   749  			
   750  				<pre>const <span id="DefaultMaxIdleConnsPerHost">DefaultMaxIdleConnsPerHost</span> = 2</pre>
   751  				<p>
   752  DefaultMaxIdleConnsPerHost is the default value of Transport's
   753  MaxIdleConnsPerHost.
   754  </p>
   755  
   756  			
   757  				<pre>const <span id="TimeFormat">TimeFormat</span> = "Mon, 02 Jan 2006 15:04:05 GMT"</pre>
   758  				<p>
   759  TimeFormat is the time format to use with
   760  time.Parse and time.Time.Format when parsing
   761  or generating times in HTTP headers.
   762  It is like time.RFC1123 but hard codes GMT as the time zone.
   763  </p>
   764  
   765  			
   766  		
   767  		
   768  			<h2 id="pkg-variables">Variables</h2>
   769  			
   770  				<pre>var (
   771          <span id="ErrHeaderTooLong">ErrHeaderTooLong</span>        = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"header too long"}
   772          <span id="ErrShortBody">ErrShortBody</span>            = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"entity body too short"}
   773          <span id="ErrNotSupported">ErrNotSupported</span>         = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"feature not supported"}
   774          <span id="ErrUnexpectedTrailer">ErrUnexpectedTrailer</span>    = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"trailer header without chunked transfer encoding"}
   775          <span id="ErrMissingContentLength">ErrMissingContentLength</span> = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"missing ContentLength in HEAD response"}
   776          <span id="ErrNotMultipart">ErrNotMultipart</span>         = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"request Content-Type isn't multipart/form-data"}
   777          <span id="ErrMissingBoundary">ErrMissingBoundary</span>      = &amp;<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>{"no multipart boundary param in Content-Type"}
   778  )</pre>
   779  				
   780  			
   781  				<pre>var (
   782          <span id="ErrWriteAfterFlush">ErrWriteAfterFlush</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("Conn.Write called after Flush")
   783          <span id="ErrBodyNotAllowed">ErrBodyNotAllowed</span>  = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: request method or response status code does not allow body")
   784          <span id="ErrHijacked">ErrHijacked</span>        = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("Conn has been hijacked")
   785          <span id="ErrContentLength">ErrContentLength</span>   = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("Conn.Write wrote more than the declared Content-Length")
   786  )</pre>
   787  				<p>
   788  Errors introduced by the HTTP server.
   789  </p>
   790  
   791  			
   792  				<pre>var <span id="DefaultClient">DefaultClient</span> = &amp;<a href="https://golang.org/pkg/net/http/#Client">Client</a>{}</pre>
   793  				<p>
   794  DefaultClient is the default Client and is used by Get, Head, and Post.
   795  </p>
   796  
   797  			
   798  				<pre>var <span id="DefaultServeMux">DefaultServeMux</span> = <a href="https://golang.org/pkg/net/http/#NewServeMux">NewServeMux</a>()</pre>
   799  				<p>
   800  DefaultServeMux is the default ServeMux used by Serve.
   801  </p>
   802  
   803  			
   804  				<pre>var <span id="ErrBodyReadAfterClose">ErrBodyReadAfterClose</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: invalid Read on closed Body")</pre>
   805  				<p>
   806  ErrBodyReadAfterClose is returned when reading a Request or Response
   807  Body after the body has been closed. This typically happens when the body is
   808  read after an HTTP Handler calls WriteHeader or Write on its
   809  ResponseWriter.
   810  </p>
   811  
   812  			
   813  				<pre>var <span id="ErrHandlerTimeout">ErrHandlerTimeout</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: Handler timeout")</pre>
   814  				<p>
   815  ErrHandlerTimeout is returned on ResponseWriter Write calls
   816  in handlers which have timed out.
   817  </p>
   818  
   819  			
   820  				<pre>var <span id="ErrLineTooLong">ErrLineTooLong</span> = <a href="https://golang.org/pkg/net/http/internal/">internal</a>.<a href="https://golang.org/pkg/net/http/internal/#ErrLineTooLong">ErrLineTooLong</a></pre>
   821  				<p>
   822  ErrLineTooLong is returned when reading request or response bodies
   823  with malformed chunked encoding.
   824  </p>
   825  
   826  			
   827  				<pre>var <span id="ErrMissingFile">ErrMissingFile</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: no such file")</pre>
   828  				<p>
   829  ErrMissingFile is returned by FormFile when the provided file field name
   830  is either not present in the request or not a file field.
   831  </p>
   832  
   833  			
   834  				<pre>var <span id="ErrNoCookie">ErrNoCookie</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: named cookie not present")</pre>
   835  				<p>
   836  ErrNoCookie is returned by Request's Cookie method when a cookie is not found.
   837  </p>
   838  
   839  			
   840  				<pre>var <span id="ErrNoLocation">ErrNoLocation</span> = <a href="https://golang.org/pkg/errors/">errors</a>.<a href="https://golang.org/pkg/errors/#New">New</a>("http: no Location header in response")</pre>
   841  				<p>
   842  ErrNoLocation is returned by Response's Location method
   843  when no Location header is present.
   844  </p>
   845  
   846  			
   847  		
   848  		
   849  			
   850  			
   851  			<h2 id="CanonicalHeaderKey">func <a href="https://golang.org/src/net/http/header.go?s=4562:4602#L163">CanonicalHeaderKey</a></h2>
   852  			<pre>func CanonicalHeaderKey(s <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
   853  			<p>
   854  CanonicalHeaderKey returns the canonical format of the
   855  header key s.  The canonicalization converts the first
   856  letter and any letter following a hyphen to upper case;
   857  the rest are converted to lowercase.  For example, the
   858  canonical key for "accept-encoding" is "Accept-Encoding".
   859  If s contains a space or invalid header field bytes, it is
   860  returned without modifications.
   861  </p>
   862  
   863  			
   864  			
   865  
   866  		
   867  			
   868  			
   869  			<h2 id="DetectContentType">func <a href="https://golang.org/src/net/http/sniff.go?s=648:690#L11">DetectContentType</a></h2>
   870  			<pre>func DetectContentType(data []<a href="https://golang.org/pkg/builtin/#byte">byte</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
   871  			<p>
   872  DetectContentType implements the algorithm described
   873  at <a href="http://mimesniff.spec.whatwg.org/">http://mimesniff.spec.whatwg.org/</a> to determine the
   874  Content-Type of the given data.  It considers at most the
   875  first 512 bytes of data.  DetectContentType always returns
   876  a valid MIME type: if it cannot determine a more specific one, it
   877  returns "application/octet-stream".
   878  </p>
   879  
   880  			
   881  			
   882  
   883  		
   884  			
   885  			
   886  			<h2 id="Error">func <a href="https://golang.org/src/net/http/server.go?s=41562:41614#L1419">Error</a></h2>
   887  			<pre>func Error(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, error <a href="https://golang.org/pkg/builtin/#string">string</a>, code <a href="https://golang.org/pkg/builtin/#int">int</a>)</pre>
   888  			<p>
   889  Error replies to the request with the specified error message and HTTP code.
   890  The error message should be plain text.
   891  </p>
   892  
   893  			
   894  			
   895  
   896  		
   897  			
   898  			
   899  			<h2 id="Handle">func <a href="https://golang.org/src/net/http/server.go?s=51434:51478#L1740">Handle</a></h2>
   900  			<pre>func Handle(pattern <a href="https://golang.org/pkg/builtin/#string">string</a>, handler <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>)</pre>
   901  			<p>
   902  Handle registers the handler for the given pattern
   903  in the DefaultServeMux.
   904  The documentation for ServeMux explains how patterns are matched.
   905  </p>
   906  
   907  			
   908  			
   909  
   910  		
   911  			
   912  			
   913  			<h2 id="HandleFunc">func <a href="https://golang.org/src/net/http/server.go?s=51688:51759#L1745">HandleFunc</a></h2>
   914  			<pre>func HandleFunc(pattern <a href="https://golang.org/pkg/builtin/#string">string</a>, handler func(<a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, *<a href="https://golang.org/pkg/net/http/#Request">Request</a>))</pre>
   915  			<p>
   916  HandleFunc registers the handler function for the given pattern
   917  in the DefaultServeMux.
   918  The documentation for ServeMux explains how patterns are matched.
   919  </p>
   920  
   921  			
   922  			
   923  
   924  		
   925  			
   926  			
   927  			<h2 id="ListenAndServe">func <a href="https://golang.org/src/net/http/server.go?s=58314:58369#L1955">ListenAndServe</a></h2>
   928  			<pre>func ListenAndServe(addr <a href="https://golang.org/pkg/builtin/#string">string</a>, handler <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
   929  			<p>
   930  ListenAndServe listens on the TCP network address addr
   931  and then calls Serve with handler to handle requests
   932  on incoming connections.  Handler is typically nil,
   933  in which case the DefaultServeMux is used.
   934  </p>
   935  <p>
   936  A trivial example server is:
   937  </p>
   938  <pre>package main
   939  
   940  import (
   941  	"io"
   942  	"net/http"
   943  	"log"
   944  )
   945  
   946  // hello world, the web server
   947  func HelloServer(w http.ResponseWriter, req *http.Request) {
   948  	io.WriteString(w, "hello, world!\n")
   949  }
   950  
   951  func main() {
   952  	http.HandleFunc("/hello", HelloServer)
   953  	err := http.ListenAndServe(":12345", nil)
   954  	if err != nil {
   955  		log.Fatal("ListenAndServe: ", err)
   956  	}
   957  }
   958  </pre>
   959  
   960  			
   961  			
   962  
   963  		
   964  			
   965  			
   966  			<h2 id="ListenAndServeTLS">func <a href="https://golang.org/src/net/http/server.go?s=59426:59517#L1988">ListenAndServeTLS</a></h2>
   967  			<pre>func ListenAndServeTLS(addr <a href="https://golang.org/pkg/builtin/#string">string</a>, certFile <a href="https://golang.org/pkg/builtin/#string">string</a>, keyFile <a href="https://golang.org/pkg/builtin/#string">string</a>, handler <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
   968  			<p>
   969  ListenAndServeTLS acts identically to ListenAndServe, except that it
   970  expects HTTPS connections. Additionally, files containing a certificate and
   971  matching private key for the server must be provided. If the certificate
   972  is signed by a certificate authority, the certFile should be the concatenation
   973  of the server's certificate, any intermediates, and the CA's certificate.
   974  </p>
   975  <p>
   976  A trivial example server is:
   977  </p>
   978  <pre>import (
   979  	"log"
   980  	"net/http"
   981  )
   982  
   983  func handler(w http.ResponseWriter, req *http.Request) {
   984  	w.Header().Set("Content-Type", "text/plain")
   985  	w.Write([]byte("This is an example server.\n"))
   986  }
   987  
   988  func main() {
   989  	http.HandleFunc("/", handler)
   990  	log.Printf("About to listen on 10443. Go to <a href="https://127.0.0.1:10443/">https://127.0.0.1:10443/</a>")
   991  	err := http.ListenAndServeTLS(":10443", "cert.pem", "key.pem", nil)
   992  	if err != nil {
   993  		log.Fatal(err)
   994  	}
   995  }
   996  </pre>
   997  <p>
   998  One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem.
   999  </p>
  1000  
  1001  			
  1002  			
  1003  
  1004  		
  1005  			
  1006  			
  1007  			<h2 id="MaxBytesReader">func <a href="https://golang.org/src/net/http/request.go?s=22939:23016#L726">MaxBytesReader</a></h2>
  1008  			<pre>func MaxBytesReader(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#ReadCloser">ReadCloser</a>, n <a href="https://golang.org/pkg/builtin/#int64">int64</a>) <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#ReadCloser">ReadCloser</a></pre>
  1009  			<p>
  1010  MaxBytesReader is similar to io.LimitReader but is intended for
  1011  limiting the size of incoming request bodies. In contrast to
  1012  io.LimitReader, MaxBytesReader's result is a ReadCloser, returns a
  1013  non-EOF error for a Read beyond the limit, and closes the
  1014  underlying reader when its Close method is called.
  1015  </p>
  1016  <p>
  1017  MaxBytesReader prevents clients from accidentally or maliciously
  1018  sending a large request and wasting server resources.
  1019  </p>
  1020  
  1021  			
  1022  			
  1023  
  1024  		
  1025  			
  1026  			
  1027  			<h2 id="NotFound">func <a href="https://golang.org/src/net/http/server.go?s=41848:41891#L1427">NotFound</a></h2>
  1028  			<pre>func NotFound(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)</pre>
  1029  			<p>
  1030  NotFound replies to the request with an HTTP 404 not found error.
  1031  </p>
  1032  
  1033  			
  1034  			
  1035  
  1036  		
  1037  			
  1038  			
  1039  			<h2 id="ParseHTTPVersion">func <a href="https://golang.org/src/net/http/request.go?s=16539:16601#L498">ParseHTTPVersion</a></h2>
  1040  			<pre>func ParseHTTPVersion(vers <a href="https://golang.org/pkg/builtin/#string">string</a>) (major, minor <a href="https://golang.org/pkg/builtin/#int">int</a>, ok <a href="https://golang.org/pkg/builtin/#bool">bool</a>)</pre>
  1041  			<p>
  1042  ParseHTTPVersion parses a HTTP version string.
  1043  "HTTP/1.0" returns (1, 0, true).
  1044  </p>
  1045  
  1046  			
  1047  			
  1048  
  1049  		
  1050  			
  1051  			
  1052  			<h2 id="ParseTime">func <a href="https://golang.org/src/net/http/header.go?s=1908:1960#L69">ParseTime</a></h2>
  1053  			<pre>func ParseTime(text <a href="https://golang.org/pkg/builtin/#string">string</a>) (t <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Time">Time</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1054  			<p>
  1055  ParseTime parses a time header (such as the Date: header),
  1056  trying each of the three formats allowed by HTTP/1.1:
  1057  TimeFormat, time.RFC850, and time.ANSIC.
  1058  </p>
  1059  
  1060  			
  1061  			
  1062  
  1063  		
  1064  			
  1065  			
  1066  			<h2 id="ProxyFromEnvironment">func <a href="https://golang.org/src/net/http/transport.go?s=4805:4862#L126">ProxyFromEnvironment</a></h2>
  1067  			<pre>func ProxyFromEnvironment(req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (*<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1068  			<p>
  1069  ProxyFromEnvironment returns the URL of the proxy to use for a
  1070  given request, as indicated by the environment variables
  1071  HTTP_PROXY, HTTPS_PROXY and NO_PROXY (or the lowercase versions
  1072  thereof). HTTPS_PROXY takes precedence over HTTP_PROXY for https
  1073  requests.
  1074  </p>
  1075  <p>
  1076  The environment values may be either a complete URL or a
  1077  "host[:port]", in which case the "http" scheme is assumed.
  1078  An error is returned if the value is a different form.
  1079  </p>
  1080  <p>
  1081  A nil URL and nil error are returned if no proxy is defined in the
  1082  environment, or a proxy should not be used for the given request,
  1083  as defined by NO_PROXY.
  1084  </p>
  1085  <p>
  1086  As a special case, if req.URL.Host is "localhost" (with or without
  1087  a port number), then a nil URL and nil error will be returned.
  1088  </p>
  1089  
  1090  			
  1091  			
  1092  
  1093  		
  1094  			
  1095  			
  1096  			<h2 id="ProxyURL">func <a href="https://golang.org/src/net/http/transport.go?s=5664:5729#L157">ProxyURL</a></h2>
  1097  			<pre>func ProxyURL(fixedURL *<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>) func(*<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (*<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1098  			<p>
  1099  ProxyURL returns a proxy function (for use in a Transport)
  1100  that always returns the same URL.
  1101  </p>
  1102  
  1103  			
  1104  			
  1105  
  1106  		
  1107  			
  1108  			
  1109  			<h2 id="Redirect">func <a href="https://golang.org/src/net/http/server.go?s=42815:42883#L1454">Redirect</a></h2>
  1110  			<pre>func Redirect(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>, urlStr <a href="https://golang.org/pkg/builtin/#string">string</a>, code <a href="https://golang.org/pkg/builtin/#int">int</a>)</pre>
  1111  			<p>
  1112  Redirect replies to the request with a redirect to url,
  1113  which may be a path relative to the request path.
  1114  </p>
  1115  
  1116  			
  1117  			
  1118  
  1119  		
  1120  			
  1121  			
  1122  			<h2 id="Serve">func <a href="https://golang.org/src/net/http/server.go?s=52072:52121#L1753">Serve</a></h2>
  1123  			<pre>func Serve(l <a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Listener">Listener</a>, handler <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  1124  			<p>
  1125  Serve accepts incoming HTTP connections on the listener l,
  1126  creating a new service goroutine for each.  The service goroutines
  1127  read requests and then call handler to reply to them.
  1128  Handler is typically nil, in which case the DefaultServeMux is used.
  1129  </p>
  1130  
  1131  			
  1132  			
  1133  
  1134  		
  1135  			
  1136  			
  1137  			<h2 id="ServeContent">func <a href="https://golang.org/src/net/http/fs.go?s=3535:3639#L107">ServeContent</a></h2>
  1138  			<pre>func ServeContent(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>, name <a href="https://golang.org/pkg/builtin/#string">string</a>, modtime <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Time">Time</a>, content <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#ReadSeeker">ReadSeeker</a>)</pre>
  1139  			<p>
  1140  ServeContent replies to the request using the content in the
  1141  provided ReadSeeker.  The main benefit of ServeContent over io.Copy
  1142  is that it handles Range requests properly, sets the MIME type, and
  1143  handles If-Modified-Since requests.
  1144  </p>
  1145  <p>
  1146  If the response's Content-Type header is not set, ServeContent
  1147  first tries to deduce the type from name's file extension and,
  1148  if that fails, falls back to reading the first block of the content
  1149  and passing it to DetectContentType.
  1150  The name is otherwise unused; in particular it can be empty and is
  1151  never sent in the response.
  1152  </p>
  1153  <p>
  1154  If modtime is not the zero time or Unix epoch, ServeContent
  1155  includes it in a Last-Modified header in the response.  If the
  1156  request includes an If-Modified-Since header, ServeContent uses
  1157  modtime to decide whether the content needs to be sent at all.
  1158  </p>
  1159  <p>
  1160  The content's Seek method must work: ServeContent uses
  1161  a seek to the end of the content to determine its size.
  1162  </p>
  1163  <p>
  1164  If the caller has set w's ETag header, ServeContent uses it to
  1165  handle requests using If-Range and If-None-Match.
  1166  </p>
  1167  <p>
  1168  Note that *os.File implements the io.ReadSeeker interface.
  1169  </p>
  1170  
  1171  			
  1172  			
  1173  
  1174  		
  1175  			
  1176  			
  1177  			<h2 id="ServeFile">func <a href="https://golang.org/src/net/http/fs.go?s=13941:13998#L443">ServeFile</a></h2>
  1178  			<pre>func ServeFile(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>, name <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  1179  			<p>
  1180  ServeFile replies to the request with the contents of the named
  1181  file or directory.
  1182  </p>
  1183  <p>
  1184  As a special case, ServeFile redirects any request where r.URL.Path
  1185  ends in "/index.html" to the same path, without the final
  1186  "index.html". To avoid such redirects either modify the path or
  1187  use ServeContent.
  1188  </p>
  1189  
  1190  			
  1191  			
  1192  
  1193  		
  1194  			
  1195  			
  1196  			<h2 id="SetCookie">func <a href="https://golang.org/src/net/http/cookie.go?s=3059:3107#L120">SetCookie</a></h2>
  1197  			<pre>func SetCookie(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, cookie *<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>)</pre>
  1198  			<p>
  1199  SetCookie adds a Set-Cookie header to the provided ResponseWriter's headers.
  1200  The provided cookie must have a valid Name. Invalid cookies may be
  1201  silently dropped.
  1202  </p>
  1203  
  1204  			
  1205  			
  1206  
  1207  		
  1208  			
  1209  			
  1210  			<h2 id="StatusText">func <a href="https://golang.org/src/net/http/status.go?s=4602:4634#L108">StatusText</a></h2>
  1211  			<pre>func StatusText(code <a href="https://golang.org/pkg/builtin/#int">int</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  1212  			<p>
  1213  StatusText returns a text for the HTTP status code. It returns the empty
  1214  string if the code is unknown.
  1215  </p>
  1216  
  1217  			
  1218  			
  1219  
  1220  		
  1221  		
  1222  			
  1223  			
  1224  			<h2 id="Client">type <a href="https://golang.org/src/net/http/client.go?s=897:2420#L26">Client</a></h2>
  1225  			<pre>type Client struct {
  1226          <span class="comment">// Transport specifies the mechanism by which individual</span>
  1227          <span class="comment">// HTTP requests are made.</span>
  1228          <span class="comment">// If nil, DefaultTransport is used.</span>
  1229          Transport <a href="https://golang.org/pkg/net/http/#RoundTripper">RoundTripper</a>
  1230  
  1231          <span class="comment">// CheckRedirect specifies the policy for handling redirects.</span>
  1232          <span class="comment">// If CheckRedirect is not nil, the client calls it before</span>
  1233          <span class="comment">// following an HTTP redirect. The arguments req and via are</span>
  1234          <span class="comment">// the upcoming request and the requests made already, oldest</span>
  1235          <span class="comment">// first. If CheckRedirect returns an error, the Client's Get</span>
  1236          <span class="comment">// method returns both the previous Response and</span>
  1237          <span class="comment">// CheckRedirect's error (wrapped in a url.Error) instead of</span>
  1238          <span class="comment">// issuing the Request req.</span>
  1239          <span class="comment">//</span>
  1240          <span class="comment">// If CheckRedirect is nil, the Client uses its default policy,</span>
  1241          <span class="comment">// which is to stop after 10 consecutive requests.</span>
  1242          CheckRedirect func(req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>, via []*<a href="https://golang.org/pkg/net/http/#Request">Request</a>) <a href="https://golang.org/pkg/builtin/#error">error</a>
  1243  
  1244          <span class="comment">// Jar specifies the cookie jar.</span>
  1245          <span class="comment">// If Jar is nil, cookies are not sent in requests and ignored</span>
  1246          <span class="comment">// in responses.</span>
  1247          Jar <a href="https://golang.org/pkg/net/http/#CookieJar">CookieJar</a>
  1248  
  1249          <span class="comment">// Timeout specifies a time limit for requests made by this</span>
  1250          <span class="comment">// Client. The timeout includes connection time, any</span>
  1251          <span class="comment">// redirects, and reading the response body. The timer remains</span>
  1252          <span class="comment">// running after Get, Head, Post, or Do return and will</span>
  1253          <span class="comment">// interrupt reading of the Response.Body.</span>
  1254          <span class="comment">//</span>
  1255          <span class="comment">// A Timeout of zero means no timeout.</span>
  1256          <span class="comment">//</span>
  1257          <span class="comment">// The Client's Transport must support the CancelRequest</span>
  1258          <span class="comment">// method or Client will return errors when attempting to make</span>
  1259          <span class="comment">// a request with Get, Head, Post, or Do. Client's default</span>
  1260          <span class="comment">// Transport (DefaultTransport) supports CancelRequest.</span>
  1261          Timeout <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a>
  1262  }</pre>
  1263  			<p>
  1264  A Client is an HTTP client. Its zero value (DefaultClient) is a
  1265  usable client that uses DefaultTransport.
  1266  </p>
  1267  <p>
  1268  The Client's Transport typically has internal state (cached TCP
  1269  connections), so Clients should be reused instead of created as
  1270  needed. Clients are safe for concurrent use by multiple goroutines.
  1271  </p>
  1272  <p>
  1273  A Client is higher-level than a RoundTripper (such as Transport)
  1274  and additionally handles HTTP details such as cookies and
  1275  redirects.
  1276  </p>
  1277  
  1278  
  1279  			
  1280  
  1281  			
  1282  
  1283  			
  1284  			
  1285  			
  1286  
  1287  			
  1288  
  1289  			
  1290  				
  1291  				<h3 id="Client.Do">func (*Client) <a href="https://golang.org/src/net/http/client.go?s=6009:6070#L163">Do</a></h3>
  1292  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Client">Client</a>) Do(req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1293  				<p>
  1294  Do sends an HTTP request and returns an HTTP response, following
  1295  policy (e.g. redirects, cookies, auth) as configured on the client.
  1296  </p>
  1297  <p>
  1298  An error is returned if caused by client policy (such as
  1299  CheckRedirect), or if there was an HTTP protocol error.
  1300  A non-2xx response doesn't cause an error.
  1301  </p>
  1302  <p>
  1303  When err is nil, resp always contains a non-nil resp.Body.
  1304  </p>
  1305  <p>
  1306  Callers should close resp.Body when done reading from it. If
  1307  resp.Body is not closed, the Client's underlying RoundTripper
  1308  (typically Transport) may not be able to re-use a persistent TCP
  1309  connection to the server for a subsequent "keep-alive" request.
  1310  </p>
  1311  <p>
  1312  The request Body, if non-nil, will be closed by the underlying
  1313  Transport, even on errors.
  1314  </p>
  1315  <p>
  1316  Generally Get, Post, or PostForm will be used instead of Do.
  1317  </p>
  1318  
  1319  				
  1320  				
  1321  				
  1322  			
  1323  				
  1324  				<h3 id="Client.Get">func (*Client) <a href="https://golang.org/src/net/http/client.go?s=9928:9988#L291">Get</a></h3>
  1325  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Client">Client</a>) Get(url <a href="https://golang.org/pkg/builtin/#string">string</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1326  				<p>
  1327  Get issues a GET to the specified URL. If the response is one of the
  1328  following redirect codes, Get follows the redirect after calling the
  1329  Client's CheckRedirect function:
  1330  </p>
  1331  <pre>301 (Moved Permanently)
  1332  302 (Found)
  1333  303 (See Other)
  1334  307 (Temporary Redirect)
  1335  </pre>
  1336  <p>
  1337  An error is returned if the Client's CheckRedirect function fails
  1338  or if there was an HTTP protocol error. A non-2xx response doesn't
  1339  cause an error.
  1340  </p>
  1341  <p>
  1342  When err is nil, resp always contains a non-nil resp.Body.
  1343  Caller should close resp.Body when done reading from it.
  1344  </p>
  1345  <p>
  1346  To make a request with custom headers, use NewRequest and Client.Do.
  1347  </p>
  1348  
  1349  				
  1350  				
  1351  				
  1352  			
  1353  				
  1354  				<h3 id="Client.Head">func (*Client) <a href="https://golang.org/src/net/http/client.go?s=16276:16337#L512">Head</a></h3>
  1355  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Client">Client</a>) Head(url <a href="https://golang.org/pkg/builtin/#string">string</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1356  				<p>
  1357  Head issues a HEAD to the specified URL.  If the response is one of the
  1358  following redirect codes, Head follows the redirect after calling the
  1359  Client's CheckRedirect function:
  1360  </p>
  1361  <pre>301 (Moved Permanently)
  1362  302 (Found)
  1363  303 (See Other)
  1364  307 (Temporary Redirect)
  1365  </pre>
  1366  
  1367  				
  1368  				
  1369  				
  1370  			
  1371  				
  1372  				<h3 id="Client.Post">func (*Client) <a href="https://golang.org/src/net/http/client.go?s=14197:14291#L455">Post</a></h3>
  1373  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Client">Client</a>) Post(url <a href="https://golang.org/pkg/builtin/#string">string</a>, bodyType <a href="https://golang.org/pkg/builtin/#string">string</a>, body <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Reader">Reader</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1374  				<p>
  1375  Post issues a POST to the specified URL.
  1376  </p>
  1377  <p>
  1378  Caller should close resp.Body when done reading from it.
  1379  </p>
  1380  <p>
  1381  If the provided body is an io.Closer, it is closed after the
  1382  request.
  1383  </p>
  1384  <p>
  1385  To set custom headers, use NewRequest and Client.Do.
  1386  </p>
  1387  
  1388  				
  1389  				
  1390  				
  1391  			
  1392  				
  1393  				<h3 id="Client.PostForm">func (*Client) <a href="https://golang.org/src/net/http/client.go?s=15401:15483#L486">PostForm</a></h3>
  1394  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Client">Client</a>) PostForm(url <a href="https://golang.org/pkg/builtin/#string">string</a>, data <a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#Values">Values</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1395  				<p>
  1396  PostForm issues a POST to the specified URL,
  1397  with data's keys and values URL-encoded as the request body.
  1398  </p>
  1399  <p>
  1400  The Content-Type header is set to application/x-www-form-urlencoded.
  1401  To set other headers, use NewRequest and DefaultClient.Do.
  1402  </p>
  1403  <p>
  1404  When err is nil, resp always contains a non-nil resp.Body.
  1405  Caller should close resp.Body when done reading from it.
  1406  </p>
  1407  
  1408  				
  1409  				
  1410  				
  1411  			
  1412  		
  1413  			
  1414  			
  1415  			<h2 id="CloseNotifier">type <a href="https://golang.org/src/net/http/server.go?s=3931:4099#L106">CloseNotifier</a></h2>
  1416  			<pre>type CloseNotifier interface {
  1417          <span class="comment">// CloseNotify returns a channel that receives a single value</span>
  1418          <span class="comment">// when the client connection has gone away.</span>
  1419          CloseNotify() &lt;-chan <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  1420  }</pre>
  1421  			<p>
  1422  The CloseNotifier interface is implemented by ResponseWriters which
  1423  allow detecting when the underlying connection has gone away.
  1424  </p>
  1425  <p>
  1426  This mechanism can be used to cancel long operations on the server
  1427  if the client has disconnected before the response is ready.
  1428  </p>
  1429  
  1430  
  1431  			
  1432  
  1433  			
  1434  
  1435  			
  1436  			
  1437  			
  1438  
  1439  			
  1440  
  1441  			
  1442  		
  1443  			
  1444  			
  1445  			<h2 id="ConnState">type <a href="https://golang.org/src/net/http/server.go?s=53915:53933#L1793">ConnState</a></h2>
  1446  			<pre>type ConnState <a href="https://golang.org/pkg/builtin/#int">int</a></pre>
  1447  			<p>
  1448  A ConnState represents the state of a client connection to a server.
  1449  It's used by the optional Server.ConnState hook.
  1450  </p>
  1451  
  1452  
  1453  			
  1454  				<pre>const (
  1455          <span class="comment">// StateNew represents a new connection that is expected to</span>
  1456          <span class="comment">// send a request immediately. Connections begin at this</span>
  1457          <span class="comment">// state and then transition to either StateActive or</span>
  1458          <span class="comment">// StateClosed.</span>
  1459          <span id="StateNew">StateNew</span> <a href="https://golang.org/pkg/net/http/#ConnState">ConnState</a> = <a href="https://golang.org/pkg/builtin/#iota">iota</a>
  1460  
  1461          <span class="comment">// StateActive represents a connection that has read 1 or more</span>
  1462          <span class="comment">// bytes of a request. The Server.ConnState hook for</span>
  1463          <span class="comment">// StateActive fires before the request has entered a handler</span>
  1464          <span class="comment">// and doesn't fire again until the request has been</span>
  1465          <span class="comment">// handled. After the request is handled, the state</span>
  1466          <span class="comment">// transitions to StateClosed, StateHijacked, or StateIdle.</span>
  1467          <span id="StateActive">StateActive</span>
  1468  
  1469          <span class="comment">// StateIdle represents a connection that has finished</span>
  1470          <span class="comment">// handling a request and is in the keep-alive state, waiting</span>
  1471          <span class="comment">// for a new request. Connections transition from StateIdle</span>
  1472          <span class="comment">// to either StateActive or StateClosed.</span>
  1473          <span id="StateIdle">StateIdle</span>
  1474  
  1475          <span class="comment">// StateHijacked represents a hijacked connection.</span>
  1476          <span class="comment">// This is a terminal state. It does not transition to StateClosed.</span>
  1477          <span id="StateHijacked">StateHijacked</span>
  1478  
  1479          <span class="comment">// StateClosed represents a closed connection.</span>
  1480          <span class="comment">// This is a terminal state. Hijacked connections do not</span>
  1481          <span class="comment">// transition to StateClosed.</span>
  1482          <span id="StateClosed">StateClosed</span>
  1483  )</pre>
  1484  				
  1485  			
  1486  
  1487  			
  1488  
  1489  			
  1490  			
  1491  			
  1492  
  1493  			
  1494  
  1495  			
  1496  				
  1497  				<h3 id="ConnState.String">func (ConnState) <a href="https://golang.org/src/net/http/server.go?s=55217:55251#L1834">String</a></h3>
  1498  				<pre>func (c <a href="https://golang.org/pkg/net/http/#ConnState">ConnState</a>) String() <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  1499  				
  1500  				
  1501  				
  1502  				
  1503  			
  1504  		
  1505  			
  1506  			
  1507  			<h2 id="Cookie">type <a href="https://golang.org/src/net/http/cookie.go?s=439:952#L11">Cookie</a></h2>
  1508  			<pre>type Cookie struct {
  1509          Name  <a href="https://golang.org/pkg/builtin/#string">string</a>
  1510          Value <a href="https://golang.org/pkg/builtin/#string">string</a>
  1511  
  1512          Path       <a href="https://golang.org/pkg/builtin/#string">string</a>    <span class="comment">// optional</span>
  1513          Domain     <a href="https://golang.org/pkg/builtin/#string">string</a>    <span class="comment">// optional</span>
  1514          Expires    <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Time">Time</a> <span class="comment">// optional</span>
  1515          RawExpires <a href="https://golang.org/pkg/builtin/#string">string</a>    <span class="comment">// for reading cookies only</span>
  1516  
  1517          <span class="comment">// MaxAge=0 means no 'Max-Age' attribute specified.</span>
  1518          <span class="comment">// MaxAge&lt;0 means delete cookie now, equivalently 'Max-Age: 0'</span>
  1519          <span class="comment">// MaxAge&gt;0 means Max-Age attribute present and given in seconds</span>
  1520          MaxAge   <a href="https://golang.org/pkg/builtin/#int">int</a>
  1521          Secure   <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  1522          HttpOnly <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  1523          Raw      <a href="https://golang.org/pkg/builtin/#string">string</a>
  1524          Unparsed []<a href="https://golang.org/pkg/builtin/#string">string</a> <span class="comment">// Raw text of unparsed attribute-value pairs</span>
  1525  }</pre>
  1526  			<p>
  1527  A Cookie represents an HTTP cookie as sent in the Set-Cookie header of an
  1528  HTTP response or the Cookie header of an HTTP request.
  1529  </p>
  1530  <p>
  1531  See <a href="http://tools.ietf.org/html/rfc6265">http://tools.ietf.org/html/rfc6265</a> for details.
  1532  </p>
  1533  
  1534  
  1535  			
  1536  
  1537  			
  1538  
  1539  			
  1540  			
  1541  			
  1542  
  1543  			
  1544  
  1545  			
  1546  				
  1547  				<h3 id="Cookie.String">func (*Cookie) <a href="https://golang.org/src/net/http/cookie.go?s=3428:3460#L130">String</a></h3>
  1548  				<pre>func (c *<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>) String() <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  1549  				<p>
  1550  String returns the serialization of the cookie for use in a Cookie
  1551  header (if only Name and Value are set) or a Set-Cookie response
  1552  header (if other fields are set).
  1553  If c is nil or c.Name is invalid, the empty string is returned.
  1554  </p>
  1555  
  1556  				
  1557  				
  1558  				
  1559  			
  1560  		
  1561  			
  1562  			
  1563  			<h2 id="CookieJar">type <a href="https://golang.org/src/net/http/jar.go?s=433:899#L7">CookieJar</a></h2>
  1564  			<pre>type CookieJar interface {
  1565          <span class="comment">// SetCookies handles the receipt of the cookies in a reply for the</span>
  1566          <span class="comment">// given URL.  It may or may not choose to save the cookies, depending</span>
  1567          <span class="comment">// on the jar's policy and implementation.</span>
  1568          SetCookies(u *<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>, cookies []*<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>)
  1569  
  1570          <span class="comment">// Cookies returns the cookies to send in a request for the given URL.</span>
  1571          <span class="comment">// It is up to the implementation to honor the standard cookie use</span>
  1572          <span class="comment">// restrictions such as in RFC 6265.</span>
  1573          Cookies(u *<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>) []*<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>
  1574  }</pre>
  1575  			<p>
  1576  A CookieJar manages storage and use of cookies in HTTP requests.
  1577  </p>
  1578  <p>
  1579  Implementations of CookieJar must be safe for concurrent use by multiple
  1580  goroutines.
  1581  </p>
  1582  <p>
  1583  The net/http/cookiejar package provides a CookieJar implementation.
  1584  </p>
  1585  
  1586  
  1587  			
  1588  
  1589  			
  1590  
  1591  			
  1592  			
  1593  			
  1594  
  1595  			
  1596  
  1597  			
  1598  		
  1599  			
  1600  			
  1601  			<h2 id="Dir">type <a href="https://golang.org/src/net/http/fs.go?s=719:734#L23">Dir</a></h2>
  1602  			<pre>type Dir <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  1603  			<p>
  1604  A Dir implements FileSystem using the native file system restricted to a
  1605  specific directory tree.
  1606  </p>
  1607  <p>
  1608  While the FileSystem.Open method takes '/'-separated paths, a Dir's string
  1609  value is a filename on the native file system, not a URL, so it is separated
  1610  by filepath.Separator, which isn't necessarily '/'.
  1611  </p>
  1612  <p>
  1613  An empty Dir is treated as ".".
  1614  </p>
  1615  
  1616  
  1617  			
  1618  
  1619  			
  1620  
  1621  			
  1622  			
  1623  			
  1624  
  1625  			
  1626  
  1627  			
  1628  				
  1629  				<h3 id="Dir.Open">func (Dir) <a href="https://golang.org/src/net/http/fs.go?s=736:780#L25">Open</a></h3>
  1630  				<pre>func (d <a href="https://golang.org/pkg/net/http/#Dir">Dir</a>) Open(name <a href="https://golang.org/pkg/builtin/#string">string</a>) (<a href="https://golang.org/pkg/net/http/#File">File</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  1631  				
  1632  				
  1633  				
  1634  				
  1635  			
  1636  		
  1637  			
  1638  			
  1639  			<h2 id="File">type <a href="https://golang.org/src/net/http/fs.go?s=1591:1755#L52">File</a></h2>
  1640  			<pre>type File interface {
  1641          <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Closer">Closer</a>
  1642          <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Reader">Reader</a>
  1643          Readdir(count <a href="https://golang.org/pkg/builtin/#int">int</a>) ([]<a href="https://golang.org/pkg/os/">os</a>.<a href="https://golang.org/pkg/os/#FileInfo">FileInfo</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  1644          Seek(offset <a href="https://golang.org/pkg/builtin/#int64">int64</a>, whence <a href="https://golang.org/pkg/builtin/#int">int</a>) (<a href="https://golang.org/pkg/builtin/#int64">int64</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  1645          Stat() (<a href="https://golang.org/pkg/os/">os</a>.<a href="https://golang.org/pkg/os/#FileInfo">FileInfo</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  1646  }</pre>
  1647  			<p>
  1648  A File is returned by a FileSystem's Open method and can be
  1649  served by the FileServer implementation.
  1650  </p>
  1651  <p>
  1652  The methods should behave the same as those on an *os.File.
  1653  </p>
  1654  
  1655  
  1656  			
  1657  
  1658  			
  1659  
  1660  			
  1661  			
  1662  			
  1663  
  1664  			
  1665  
  1666  			
  1667  		
  1668  			
  1669  			
  1670  			<h2 id="FileSystem">type <a href="https://golang.org/src/net/http/fs.go?s=1354:1416#L44">FileSystem</a></h2>
  1671  			<pre>type FileSystem interface {
  1672          Open(name <a href="https://golang.org/pkg/builtin/#string">string</a>) (<a href="https://golang.org/pkg/net/http/#File">File</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  1673  }</pre>
  1674  			<p>
  1675  A FileSystem implements access to a collection of named files.
  1676  The elements in a file path are separated by slash ('/', U+002F)
  1677  characters, regardless of host operating system convention.
  1678  </p>
  1679  
  1680  
  1681  			
  1682  
  1683  			
  1684  
  1685  			
  1686  			
  1687  			
  1688  
  1689  			
  1690  
  1691  			
  1692  		
  1693  			
  1694  			
  1695  			<h2 id="Flusher">type <a href="https://golang.org/src/net/http/server.go?s=2921:3005#L79">Flusher</a></h2>
  1696  			<pre>type Flusher interface {
  1697          <span class="comment">// Flush sends any buffered data to the client.</span>
  1698          Flush()
  1699  }</pre>
  1700  			<p>
  1701  The Flusher interface is implemented by ResponseWriters that allow
  1702  an HTTP handler to flush buffered data to the client.
  1703  </p>
  1704  <p>
  1705  Note that even for ResponseWriters that support Flush,
  1706  if the client is connected through an HTTP proxy,
  1707  the buffered data may not reach the client until the response
  1708  completes.
  1709  </p>
  1710  
  1711  
  1712  			
  1713  
  1714  			
  1715  
  1716  			
  1717  			
  1718  			
  1719  
  1720  			
  1721  
  1722  			
  1723  		
  1724  			
  1725  			
  1726  			<h2 id="Handler">type <a href="https://golang.org/src/net/http/server.go?s=1361:1424#L42">Handler</a></h2>
  1727  			<pre>type Handler interface {
  1728          ServeHTTP(<a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)
  1729  }</pre>
  1730  			<p>
  1731  Objects implementing the Handler interface can be
  1732  registered to serve a particular path or subtree
  1733  in the HTTP server.
  1734  </p>
  1735  <p>
  1736  ServeHTTP should write reply headers and data to the ResponseWriter
  1737  and then return.  Returning signals that the request is finished
  1738  and that the HTTP server can move on to the next request on
  1739  the connection.
  1740  </p>
  1741  <p>
  1742  If ServeHTTP panics, the server (the caller of ServeHTTP) assumes
  1743  that the effect of the panic was isolated to the active request.
  1744  It recovers the panic, logs a stack trace to the server error log,
  1745  and hangs up the connection.
  1746  </p>
  1747  
  1748  
  1749  			
  1750  
  1751  			
  1752  
  1753  			
  1754  			
  1755  			
  1756  
  1757  			
  1758  				
  1759  				<h3 id="FileServer">func <a href="https://golang.org/src/net/http/fs.go?s=14534:14574#L463">FileServer</a></h3>
  1760  				<pre>func FileServer(root <a href="https://golang.org/pkg/net/http/#FileSystem">FileSystem</a>) <a href="https://golang.org/pkg/net/http/#Handler">Handler</a></pre>
  1761  				<p>
  1762  FileServer returns a handler that serves HTTP requests
  1763  with the contents of the file system rooted at root.
  1764  </p>
  1765  <p>
  1766  To use the operating system's file system implementation,
  1767  use http.Dir:
  1768  </p>
  1769  <pre>http.Handle("/", http.FileServer(http.Dir("/tmp")))
  1770  </pre>
  1771  <p>
  1772  As a special case, the returned file server redirects any request
  1773  ending in "/index.html" to the same path, without the final
  1774  "index.html".
  1775  </p>
  1776  
  1777  				<div id="example_FileServer" class="toggle">
  1778  	<div class="collapsed">
  1779  		<p class="exampleHeading toggleButton">▹ <span class="text">Example</span></p>
  1780  	</div>
  1781  	<div class="expanded">
  1782  		<p class="exampleHeading toggleButton">▾ <span class="text">Example</span></p>
  1783  		
  1784  		
  1785  		
  1786  			<div class="play">
  1787  				<div class="input"><textarea class="code">package main
  1788  
  1789  import (
  1790  	"log"
  1791  	"net/http"
  1792  )
  1793  
  1794  func main() {
  1795  	// Simple static webserver:
  1796  	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))
  1797  }
  1798  </textarea></div>
  1799  				<div class="output"><pre></pre></div>
  1800  				<div class="buttons">
  1801  					<a class="run" title="Run this code [shift-enter]">Run</a>
  1802  					<a class="fmt" title="Format this code">Format</a>
  1803  					
  1804  				</div>
  1805  			</div>
  1806  		
  1807  	</div>
  1808  </div>
  1809  <div id="example_FileServer_stripPrefix" class="toggle">
  1810  	<div class="collapsed">
  1811  		<p class="exampleHeading toggleButton">▹ <span class="text">Example (StripPrefix)</span></p>
  1812  	</div>
  1813  	<div class="expanded">
  1814  		<p class="exampleHeading toggleButton">▾ <span class="text">Example (StripPrefix)</span></p>
  1815  		
  1816  		
  1817  		
  1818  			<div class="play">
  1819  				<div class="input"><textarea class="code">package main
  1820  
  1821  import (
  1822  	"net/http"
  1823  )
  1824  
  1825  func main() {
  1826  	// To serve a directory on disk (/tmp) under an alternate URL
  1827  	// path (/tmpfiles/), use StripPrefix to modify the request
  1828  	// URL's path before the FileServer sees it:
  1829  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
  1830  }
  1831  </textarea></div>
  1832  				<div class="output"><pre></pre></div>
  1833  				<div class="buttons">
  1834  					<a class="run" title="Run this code [shift-enter]">Run</a>
  1835  					<a class="fmt" title="Format this code">Format</a>
  1836  					
  1837  				</div>
  1838  			</div>
  1839  		
  1840  	</div>
  1841  </div>
  1842  
  1843  				
  1844  			
  1845  				
  1846  				<h3 id="NotFoundHandler">func <a href="https://golang.org/src/net/http/server.go?s=42065:42095#L1431">NotFoundHandler</a></h3>
  1847  				<pre>func NotFoundHandler() <a href="https://golang.org/pkg/net/http/#Handler">Handler</a></pre>
  1848  				<p>
  1849  NotFoundHandler returns a simple request handler
  1850  that replies to each request with a “404 page not found” reply.
  1851  </p>
  1852  
  1853  				
  1854  				
  1855  			
  1856  				
  1857  				<h3 id="RedirectHandler">func <a href="https://golang.org/src/net/http/server.go?s=45249:45299#L1538">RedirectHandler</a></h3>
  1858  				<pre>func RedirectHandler(url <a href="https://golang.org/pkg/builtin/#string">string</a>, code <a href="https://golang.org/pkg/builtin/#int">int</a>) <a href="https://golang.org/pkg/net/http/#Handler">Handler</a></pre>
  1859  				<p>
  1860  RedirectHandler returns a request handler that redirects
  1861  each request it receives to the given url using the given
  1862  status code.
  1863  </p>
  1864  
  1865  				
  1866  				
  1867  			
  1868  				
  1869  				<h3 id="StripPrefix">func <a href="https://golang.org/src/net/http/server.go?s=42404:42454#L1438">StripPrefix</a></h3>
  1870  				<pre>func StripPrefix(prefix <a href="https://golang.org/pkg/builtin/#string">string</a>, h <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>) <a href="https://golang.org/pkg/net/http/#Handler">Handler</a></pre>
  1871  				<p>
  1872  StripPrefix returns a handler that serves HTTP requests
  1873  by removing the given prefix from the request URL's Path
  1874  and invoking the handler h. StripPrefix handles a
  1875  request for a path that doesn't begin with prefix by
  1876  replying with an HTTP 404 not found error.
  1877  </p>
  1878  
  1879  				<div id="example_StripPrefix" class="toggle">
  1880  	<div class="collapsed">
  1881  		<p class="exampleHeading toggleButton">▹ <span class="text">Example</span></p>
  1882  	</div>
  1883  	<div class="expanded">
  1884  		<p class="exampleHeading toggleButton">▾ <span class="text">Example</span></p>
  1885  		
  1886  		
  1887  		
  1888  			<div class="play">
  1889  				<div class="input"><textarea class="code">package main
  1890  
  1891  import (
  1892  	"net/http"
  1893  )
  1894  
  1895  func main() {
  1896  	// To serve a directory on disk (/tmp) under an alternate URL
  1897  	// path (/tmpfiles/), use StripPrefix to modify the request
  1898  	// URL's path before the FileServer sees it:
  1899  	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
  1900  }
  1901  </textarea></div>
  1902  				<div class="output"><pre></pre></div>
  1903  				<div class="buttons">
  1904  					<a class="run" title="Run this code [shift-enter]">Run</a>
  1905  					<a class="fmt" title="Format this code">Format</a>
  1906  					
  1907  				</div>
  1908  			</div>
  1909  		
  1910  	</div>
  1911  </div>
  1912  
  1913  				
  1914  			
  1915  				
  1916  				<h3 id="TimeoutHandler">func <a href="https://golang.org/src/net/http/server.go?s=61275:61343#L2039">TimeoutHandler</a></h3>
  1917  				<pre>func TimeoutHandler(h <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>, dt <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a>, msg <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/net/http/#Handler">Handler</a></pre>
  1918  				<p>
  1919  TimeoutHandler returns a Handler that runs h with the given time limit.
  1920  </p>
  1921  <p>
  1922  The new Handler calls h.ServeHTTP to handle each request, but if a
  1923  call runs for longer than its time limit, the handler responds with
  1924  a 503 Service Unavailable error and the given message in its body.
  1925  (If msg is empty, a suitable default message will be sent.)
  1926  After such a timeout, writes by h to its ResponseWriter will return
  1927  ErrHandlerTimeout.
  1928  </p>
  1929  
  1930  				
  1931  				
  1932  			
  1933  
  1934  			
  1935  		
  1936  			
  1937  			
  1938  			<h2 id="HandlerFunc">type <a href="https://golang.org/src/net/http/server.go?s=41267:41314#L1408">HandlerFunc</a></h2>
  1939  			<pre>type HandlerFunc func(<a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)</pre>
  1940  			<p>
  1941  The HandlerFunc type is an adapter to allow the use of
  1942  ordinary functions as HTTP handlers.  If f is a function
  1943  with the appropriate signature, HandlerFunc(f) is a
  1944  Handler object that calls f.
  1945  </p>
  1946  
  1947  
  1948  			
  1949  
  1950  			
  1951  
  1952  			
  1953  			
  1954  			
  1955  
  1956  			
  1957  
  1958  			
  1959  				
  1960  				<h3 id="HandlerFunc.ServeHTTP">func (HandlerFunc) <a href="https://golang.org/src/net/http/server.go?s=41344:41404#L1411">ServeHTTP</a></h3>
  1961  				<pre>func (f <a href="https://golang.org/pkg/net/http/#HandlerFunc">HandlerFunc</a>) ServeHTTP(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)</pre>
  1962  				<p>
  1963  ServeHTTP calls f(w, r).
  1964  </p>
  1965  
  1966  				
  1967  				
  1968  				
  1969  			
  1970  		
  1971  			
  1972  			
  1973  			<h2 id="Header">type <a href="https://golang.org/src/net/http/header.go?s=350:381#L9">Header</a></h2>
  1974  			<pre>type Header map[<a href="https://golang.org/pkg/builtin/#string">string</a>][]<a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  1975  			<p>
  1976  A Header represents the key-value pairs in an HTTP header.
  1977  </p>
  1978  
  1979  
  1980  			
  1981  
  1982  			
  1983  
  1984  			
  1985  			
  1986  			
  1987  
  1988  			
  1989  
  1990  			
  1991  				
  1992  				<h3 id="Header.Add">func (Header) <a href="https://golang.org/src/net/http/header.go?s=488:526#L13">Add</a></h3>
  1993  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) Add(key, value <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  1994  				<p>
  1995  Add adds the key, value pair to the header.
  1996  It appends to any existing values associated with key.
  1997  </p>
  1998  
  1999  				
  2000  				
  2001  				
  2002  			
  2003  				
  2004  				<h3 id="Header.Del">func (Header) <a href="https://golang.org/src/net/http/header.go?s=1321:1352#L41">Del</a></h3>
  2005  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) Del(key <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  2006  				<p>
  2007  Del deletes the values associated with key.
  2008  </p>
  2009  
  2010  				
  2011  				
  2012  				
  2013  			
  2014  				
  2015  				<h3 id="Header.Get">func (Header) <a href="https://golang.org/src/net/http/header.go?s=1015:1053#L28">Get</a></h3>
  2016  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) Get(key <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2017  				<p>
  2018  Get gets the first value associated with the given key.
  2019  If there are no values associated with the key, Get returns "".
  2020  To access multiple values of a key, access the map directly
  2021  with CanonicalHeaderKey.
  2022  </p>
  2023  
  2024  				
  2025  				
  2026  				
  2027  			
  2028  				
  2029  				<h3 id="Header.Set">func (Header) <a href="https://golang.org/src/net/http/header.go?s=713:751#L20">Set</a></h3>
  2030  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) Set(key, value <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  2031  				<p>
  2032  Set sets the header entries associated with key to
  2033  the single element value.  It replaces any existing
  2034  values associated with key.
  2035  </p>
  2036  
  2037  				
  2038  				
  2039  				
  2040  			
  2041  				
  2042  				<h3 id="Header.Write">func (Header) <a href="https://golang.org/src/net/http/header.go?s=1433:1473#L46">Write</a></h3>
  2043  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) Write(w <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Writer">Writer</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2044  				<p>
  2045  Write writes a header in wire format.
  2046  </p>
  2047  
  2048  				
  2049  				
  2050  				
  2051  			
  2052  				
  2053  				<h3 id="Header.WriteSubset">func (Header) <a href="https://golang.org/src/net/http/header.go?s=3676:3747#L135">WriteSubset</a></h3>
  2054  				<pre>func (h <a href="https://golang.org/pkg/net/http/#Header">Header</a>) WriteSubset(w <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Writer">Writer</a>, exclude map[<a href="https://golang.org/pkg/builtin/#string">string</a>]<a href="https://golang.org/pkg/builtin/#bool">bool</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2055  				<p>
  2056  WriteSubset writes a header in wire format.
  2057  If exclude is not nil, keys where exclude[key] == true are not written.
  2058  </p>
  2059  
  2060  				
  2061  				
  2062  				
  2063  			
  2064  		
  2065  			
  2066  			
  2067  			<h2 id="Hijacker">type <a href="https://golang.org/src/net/http/server.go?s=3126:3656#L86">Hijacker</a></h2>
  2068  			<pre>type Hijacker interface {
  2069          <span class="comment">// Hijack lets the caller take over the connection.</span>
  2070          <span class="comment">// After a call to Hijack(), the HTTP server library</span>
  2071          <span class="comment">// will not do anything else with the connection.</span>
  2072          <span class="comment">//</span>
  2073          <span class="comment">// It becomes the caller's responsibility to manage</span>
  2074          <span class="comment">// and close the connection.</span>
  2075          <span class="comment">//</span>
  2076          <span class="comment">// The returned net.Conn may have read or write deadlines</span>
  2077          <span class="comment">// already set, depending on the configuration of the</span>
  2078          <span class="comment">// Server. It is the caller's responsibility to set</span>
  2079          <span class="comment">// or clear those deadlines as needed.</span>
  2080          Hijack() (<a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Conn">Conn</a>, *<a href="https://golang.org/pkg/bufio/">bufio</a>.<a href="https://golang.org/pkg/bufio/#ReadWriter">ReadWriter</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  2081  }</pre>
  2082  			<p>
  2083  The Hijacker interface is implemented by ResponseWriters that allow
  2084  an HTTP handler to take over the connection.
  2085  </p>
  2086  
  2087  
  2088  			
  2089  
  2090  			
  2091  
  2092  			<div id="example_Hijacker" class="toggle">
  2093  	<div class="collapsed">
  2094  		<p class="exampleHeading toggleButton">▹ <span class="text">Example</span></p>
  2095  	</div>
  2096  	<div class="expanded">
  2097  		<p class="exampleHeading toggleButton">▾ <span class="text">Example</span></p>
  2098  		
  2099  		
  2100  		
  2101  			<div class="play">
  2102  				<div class="input"><textarea class="code">package main
  2103  
  2104  import (
  2105  	"fmt"
  2106  	"log"
  2107  	"net/http"
  2108  )
  2109  
  2110  func main() {
  2111  	http.HandleFunc("/hijack", func(w http.ResponseWriter, r *http.Request) {
  2112  		hj, ok := w.(http.Hijacker)
  2113  		if !ok {
  2114  			http.Error(w, "webserver doesn't support hijacking", http.StatusInternalServerError)
  2115  			return
  2116  		}
  2117  		conn, bufrw, err := hj.Hijack()
  2118  		if err != nil {
  2119  			http.Error(w, err.Error(), http.StatusInternalServerError)
  2120  			return
  2121  		}
  2122  		// Don't forget to close the connection:
  2123  		defer conn.Close()
  2124  		bufrw.WriteString("Now we're speaking raw TCP. Say hi: ")
  2125  		bufrw.Flush()
  2126  		s, err := bufrw.ReadString('\n')
  2127  		if err != nil {
  2128  			log.Printf("error reading string: %v", err)
  2129  			return
  2130  		}
  2131  		fmt.Fprintf(bufrw, "You said: %q\nBye.\n", s)
  2132  		bufrw.Flush()
  2133  	})
  2134  }
  2135  </textarea></div>
  2136  				<div class="output"><pre></pre></div>
  2137  				<div class="buttons">
  2138  					<a class="run" title="Run this code [shift-enter]">Run</a>
  2139  					<a class="fmt" title="Format this code">Format</a>
  2140  					
  2141  				</div>
  2142  			</div>
  2143  		
  2144  	</div>
  2145  </div>
  2146  
  2147  			
  2148  			
  2149  
  2150  			
  2151  
  2152  			
  2153  		
  2154  			
  2155  			
  2156  			<h2 id="ProtocolError">type <a href="https://golang.org/src/net/http/request.go?s=668:717#L26">ProtocolError</a></h2>
  2157  			<pre>type ProtocolError struct {
  2158          ErrorString <a href="https://golang.org/pkg/builtin/#string">string</a>
  2159  }</pre>
  2160  			<p>
  2161  HTTP request parsing errors.
  2162  </p>
  2163  
  2164  
  2165  			
  2166  
  2167  			
  2168  
  2169  			
  2170  			
  2171  			
  2172  
  2173  			
  2174  
  2175  			
  2176  				
  2177  				<h3 id="ProtocolError.Error">func (*ProtocolError) <a href="https://golang.org/src/net/http/request.go?s=719:759#L30">Error</a></h3>
  2178  				<pre>func (err *<a href="https://golang.org/pkg/net/http/#ProtocolError">ProtocolError</a>) Error() <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2179  				
  2180  				
  2181  				
  2182  				
  2183  			
  2184  		
  2185  			
  2186  			
  2187  			<h2 id="Request">type <a href="https://golang.org/src/net/http/request.go?s=2057:8270#L64">Request</a></h2>
  2188  			<pre>type Request struct {
  2189          <span class="comment">// Method specifies the HTTP method (GET, POST, PUT, etc.).</span>
  2190          <span class="comment">// For client requests an empty string means GET.</span>
  2191          Method <a href="https://golang.org/pkg/builtin/#string">string</a>
  2192  
  2193          <span class="comment">// URL specifies either the URI being requested (for server</span>
  2194          <span class="comment">// requests) or the URL to access (for client requests).</span>
  2195          <span class="comment">//</span>
  2196          <span class="comment">// For server requests the URL is parsed from the URI</span>
  2197          <span class="comment">// supplied on the Request-Line as stored in RequestURI.  For</span>
  2198          <span class="comment">// most requests, fields other than Path and RawQuery will be</span>
  2199          <span class="comment">// empty. (See RFC 2616, Section 5.1.2)</span>
  2200          <span class="comment">//</span>
  2201          <span class="comment">// For client requests, the URL's Host specifies the server to</span>
  2202          <span class="comment">// connect to, while the Request's Host field optionally</span>
  2203          <span class="comment">// specifies the Host header value to send in the HTTP</span>
  2204          <span class="comment">// request.</span>
  2205          URL *<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>
  2206  
  2207          <span class="comment">// The protocol version for incoming requests.</span>
  2208          <span class="comment">// Client requests always use HTTP/1.1.</span>
  2209          Proto      <a href="https://golang.org/pkg/builtin/#string">string</a> <span class="comment">// "HTTP/1.0"</span>
  2210          ProtoMajor <a href="https://golang.org/pkg/builtin/#int">int</a>    <span class="comment">// 1</span>
  2211          ProtoMinor <a href="https://golang.org/pkg/builtin/#int">int</a>    <span class="comment">// 0</span>
  2212  
  2213          <span class="comment">// A header maps request lines to their values.</span>
  2214          <span class="comment">// If the header says</span>
  2215          <span class="comment">//</span>
  2216          <span class="comment">//	accept-encoding: gzip, deflate</span>
  2217          <span class="comment">//	Accept-Language: en-us</span>
  2218          <span class="comment">//	Connection: keep-alive</span>
  2219          <span class="comment">//</span>
  2220          <span class="comment">// then</span>
  2221          <span class="comment">//</span>
  2222          <span class="comment">//	Header = map[string][]string{</span>
  2223          <span class="comment">//		"Accept-Encoding": {"gzip, deflate"},</span>
  2224          <span class="comment">//		"Accept-Language": {"en-us"},</span>
  2225          <span class="comment">//		"Connection": {"keep-alive"},</span>
  2226          <span class="comment">//	}</span>
  2227          <span class="comment">//</span>
  2228          <span class="comment">// HTTP defines that header names are case-insensitive.</span>
  2229          <span class="comment">// The request parser implements this by canonicalizing the</span>
  2230          <span class="comment">// name, making the first character and any characters</span>
  2231          <span class="comment">// following a hyphen uppercase and the rest lowercase.</span>
  2232          <span class="comment">//</span>
  2233          <span class="comment">// For client requests certain headers are automatically</span>
  2234          <span class="comment">// added and may override values in Header.</span>
  2235          <span class="comment">//</span>
  2236          <span class="comment">// See the documentation for the Request.Write method.</span>
  2237          Header <a href="https://golang.org/pkg/net/http/#Header">Header</a>
  2238  
  2239          <span class="comment">// Body is the request's body.</span>
  2240          <span class="comment">//</span>
  2241          <span class="comment">// For client requests a nil body means the request has no</span>
  2242          <span class="comment">// body, such as a GET request. The HTTP Client's Transport</span>
  2243          <span class="comment">// is responsible for calling the Close method.</span>
  2244          <span class="comment">//</span>
  2245          <span class="comment">// For server requests the Request Body is always non-nil</span>
  2246          <span class="comment">// but will return EOF immediately when no body is present.</span>
  2247          <span class="comment">// The Server will close the request body. The ServeHTTP</span>
  2248          <span class="comment">// Handler does not need to.</span>
  2249          Body <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#ReadCloser">ReadCloser</a>
  2250  
  2251          <span class="comment">// ContentLength records the length of the associated content.</span>
  2252          <span class="comment">// The value -1 indicates that the length is unknown.</span>
  2253          <span class="comment">// Values &gt;= 0 indicate that the given number of bytes may</span>
  2254          <span class="comment">// be read from Body.</span>
  2255          <span class="comment">// For client requests, a value of 0 means unknown if Body is not nil.</span>
  2256          ContentLength <a href="https://golang.org/pkg/builtin/#int64">int64</a>
  2257  
  2258          <span class="comment">// TransferEncoding lists the transfer encodings from outermost to</span>
  2259          <span class="comment">// innermost. An empty list denotes the "identity" encoding.</span>
  2260          <span class="comment">// TransferEncoding can usually be ignored; chunked encoding is</span>
  2261          <span class="comment">// automatically added and removed as necessary when sending and</span>
  2262          <span class="comment">// receiving requests.</span>
  2263          TransferEncoding []<a href="https://golang.org/pkg/builtin/#string">string</a>
  2264  
  2265          <span class="comment">// Close indicates whether to close the connection after</span>
  2266          <span class="comment">// replying to this request (for servers) or after sending</span>
  2267          <span class="comment">// the request (for clients).</span>
  2268          Close <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  2269  
  2270          <span class="comment">// For server requests Host specifies the host on which the</span>
  2271          <span class="comment">// URL is sought. Per RFC 2616, this is either the value of</span>
  2272          <span class="comment">// the "Host" header or the host name given in the URL itself.</span>
  2273          <span class="comment">// It may be of the form "host:port".</span>
  2274          <span class="comment">//</span>
  2275          <span class="comment">// For client requests Host optionally overrides the Host</span>
  2276          <span class="comment">// header to send. If empty, the Request.Write method uses</span>
  2277          <span class="comment">// the value of URL.Host.</span>
  2278          Host <a href="https://golang.org/pkg/builtin/#string">string</a>
  2279  
  2280          <span class="comment">// Form contains the parsed form data, including both the URL</span>
  2281          <span class="comment">// field's query parameters and the POST or PUT form data.</span>
  2282          <span class="comment">// This field is only available after ParseForm is called.</span>
  2283          <span class="comment">// The HTTP client ignores Form and uses Body instead.</span>
  2284          Form <a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#Values">Values</a>
  2285  
  2286          <span class="comment">// PostForm contains the parsed form data from POST, PATCH,</span>
  2287          <span class="comment">// or PUT body parameters.</span>
  2288          <span class="comment">//</span>
  2289          <span class="comment">// This field is only available after ParseForm is called.</span>
  2290          <span class="comment">// The HTTP client ignores PostForm and uses Body instead.</span>
  2291          PostForm <a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#Values">Values</a>
  2292  
  2293          <span class="comment">// MultipartForm is the parsed multipart form, including file uploads.</span>
  2294          <span class="comment">// This field is only available after ParseMultipartForm is called.</span>
  2295          <span class="comment">// The HTTP client ignores MultipartForm and uses Body instead.</span>
  2296          MultipartForm *<a href="https://golang.org/pkg/mime/multipart/">multipart</a>.<a href="https://golang.org/pkg/mime/multipart/#Form">Form</a>
  2297  
  2298          <span class="comment">// Trailer specifies additional headers that are sent after the request</span>
  2299          <span class="comment">// body.</span>
  2300          <span class="comment">//</span>
  2301          <span class="comment">// For server requests the Trailer map initially contains only the</span>
  2302          <span class="comment">// trailer keys, with nil values. (The client declares which trailers it</span>
  2303          <span class="comment">// will later send.)  While the handler is reading from Body, it must</span>
  2304          <span class="comment">// not reference Trailer. After reading from Body returns EOF, Trailer</span>
  2305          <span class="comment">// can be read again and will contain non-nil values, if they were sent</span>
  2306          <span class="comment">// by the client.</span>
  2307          <span class="comment">//</span>
  2308          <span class="comment">// For client requests Trailer must be initialized to a map containing</span>
  2309          <span class="comment">// the trailer keys to later send. The values may be nil or their final</span>
  2310          <span class="comment">// values. The ContentLength must be 0 or -1, to send a chunked request.</span>
  2311          <span class="comment">// After the HTTP request is sent the map values can be updated while</span>
  2312          <span class="comment">// the request body is read. Once the body returns EOF, the caller must</span>
  2313          <span class="comment">// not mutate Trailer.</span>
  2314          <span class="comment">//</span>
  2315          <span class="comment">// Few HTTP clients, servers, or proxies support HTTP trailers.</span>
  2316          Trailer <a href="https://golang.org/pkg/net/http/#Header">Header</a>
  2317  
  2318          <span class="comment">// RemoteAddr allows HTTP servers and other software to record</span>
  2319          <span class="comment">// the network address that sent the request, usually for</span>
  2320          <span class="comment">// logging. This field is not filled in by ReadRequest and</span>
  2321          <span class="comment">// has no defined format. The HTTP server in this package</span>
  2322          <span class="comment">// sets RemoteAddr to an "IP:port" address before invoking a</span>
  2323          <span class="comment">// handler.</span>
  2324          <span class="comment">// This field is ignored by the HTTP client.</span>
  2325          RemoteAddr <a href="https://golang.org/pkg/builtin/#string">string</a>
  2326  
  2327          <span class="comment">// RequestURI is the unmodified Request-URI of the</span>
  2328          <span class="comment">// Request-Line (RFC 2616, Section 5.1) as sent by the client</span>
  2329          <span class="comment">// to a server. Usually the URL field should be used instead.</span>
  2330          <span class="comment">// It is an error to set this field in an HTTP client request.</span>
  2331          RequestURI <a href="https://golang.org/pkg/builtin/#string">string</a>
  2332  
  2333          <span class="comment">// TLS allows HTTP servers and other software to record</span>
  2334          <span class="comment">// information about the TLS connection on which the request</span>
  2335          <span class="comment">// was received. This field is not filled in by ReadRequest.</span>
  2336          <span class="comment">// The HTTP server in this package sets the field for</span>
  2337          <span class="comment">// TLS-enabled connections before invoking a handler;</span>
  2338          <span class="comment">// otherwise it leaves the field nil.</span>
  2339          <span class="comment">// This field is ignored by the HTTP client.</span>
  2340          TLS *<a href="https://golang.org/pkg/crypto/tls/">tls</a>.<a href="https://golang.org/pkg/crypto/tls/#ConnectionState">ConnectionState</a>
  2341  
  2342          <span class="comment">// Cancel is an optional channel whose closure indicates that the client</span>
  2343          <span class="comment">// request should be regarded as canceled. Not all implementations of</span>
  2344          <span class="comment">// RoundTripper may support Cancel.</span>
  2345          <span class="comment">//</span>
  2346          <span class="comment">// For server requests, this field is not applicable.</span>
  2347          Cancel &lt;-chan struct{}
  2348  }</pre>
  2349  			<p>
  2350  A Request represents an HTTP request received by a server
  2351  or to be sent by a client.
  2352  </p>
  2353  <p>
  2354  The field semantics differ slightly between client and server
  2355  usage. In addition to the notes on the fields below, see the
  2356  documentation for Request.Write and RoundTripper.
  2357  </p>
  2358  
  2359  
  2360  			
  2361  
  2362  			
  2363  
  2364  			
  2365  			
  2366  			
  2367  
  2368  			
  2369  				
  2370  				<h3 id="NewRequest">func <a href="https://golang.org/src/net/http/request.go?s=17718:17790#L536">NewRequest</a></h3>
  2371  				<pre>func NewRequest(method, urlStr <a href="https://golang.org/pkg/builtin/#string">string</a>, body <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Reader">Reader</a>) (*<a href="https://golang.org/pkg/net/http/#Request">Request</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2372  				<p>
  2373  NewRequest returns a new Request given a method, URL, and optional body.
  2374  </p>
  2375  <p>
  2376  If the provided body is also an io.Closer, the returned
  2377  Request.Body is set to body and will be closed by the Client
  2378  methods Do, Post, and PostForm, and Transport.RoundTrip.
  2379  </p>
  2380  <p>
  2381  NewRequest returns a Request suitable for use with Client.Do or
  2382  Transport.RoundTrip.
  2383  To create a request for use with testing a Server Handler use either
  2384  ReadRequest or manually update the Request fields. See the Request
  2385  type's documentation for the difference between inbound and outbound
  2386  request fields.
  2387  </p>
  2388  
  2389  				
  2390  				
  2391  			
  2392  				
  2393  				<h3 id="ReadRequest">func <a href="https://golang.org/src/net/http/request.go?s=20301:20360#L636">ReadRequest</a></h3>
  2394  				<pre>func ReadRequest(b *<a href="https://golang.org/pkg/bufio/">bufio</a>.<a href="https://golang.org/pkg/bufio/#Reader">Reader</a>) (req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2395  				<p>
  2396  ReadRequest reads and parses an incoming request from b.
  2397  </p>
  2398  
  2399  				
  2400  				
  2401  			
  2402  
  2403  			
  2404  				
  2405  				<h3 id="Request.AddCookie">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=9423:9461#L259">AddCookie</a></h3>
  2406  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) AddCookie(c *<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>)</pre>
  2407  				<p>
  2408  AddCookie adds a cookie to the request.  Per RFC 6265 section 5.4,
  2409  AddCookie does not attach more than one Cookie header field.  That
  2410  means all cookies, if any, are written into the same line,
  2411  separated by semicolon.
  2412  </p>
  2413  
  2414  				
  2415  				
  2416  				
  2417  			
  2418  				
  2419  				<h3 id="Request.BasicAuth">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=18567:18633#L572">BasicAuth</a></h3>
  2420  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) BasicAuth() (username, password <a href="https://golang.org/pkg/builtin/#string">string</a>, ok <a href="https://golang.org/pkg/builtin/#bool">bool</a>)</pre>
  2421  				<p>
  2422  BasicAuth returns the username and password provided in the request's
  2423  Authorization header, if the request uses HTTP Basic Authentication.
  2424  See RFC 2617, Section 2.
  2425  </p>
  2426  
  2427  				
  2428  				
  2429  				
  2430  			
  2431  				
  2432  				<h3 id="Request.Cookie">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=9041:9095#L248">Cookie</a></h3>
  2433  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) Cookie(name <a href="https://golang.org/pkg/builtin/#string">string</a>) (*<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2434  				<p>
  2435  Cookie returns the named cookie provided in the request or
  2436  ErrNoCookie if not found.
  2437  </p>
  2438  
  2439  				
  2440  				
  2441  				
  2442  			
  2443  				
  2444  				<h3 id="Request.Cookies">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=8727:8764#L239">Cookies</a></h3>
  2445  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) Cookies() []*<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a></pre>
  2446  				<p>
  2447  Cookies parses and returns the HTTP cookies sent with the request.
  2448  </p>
  2449  
  2450  				
  2451  				
  2452  				
  2453  			
  2454  				
  2455  				<h3 id="Request.FormFile">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=29076:29161#L960">FormFile</a></h3>
  2456  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) FormFile(key <a href="https://golang.org/pkg/builtin/#string">string</a>) (<a href="https://golang.org/pkg/mime/multipart/">multipart</a>.<a href="https://golang.org/pkg/mime/multipart/#File">File</a>, *<a href="https://golang.org/pkg/mime/multipart/">multipart</a>.<a href="https://golang.org/pkg/mime/multipart/#FileHeader">FileHeader</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2457  				<p>
  2458  FormFile returns the first file for the provided form key.
  2459  FormFile calls ParseMultipartForm and ParseForm if necessary.
  2460  </p>
  2461  
  2462  				
  2463  				
  2464  				
  2465  			
  2466  				
  2467  				<h3 id="Request.FormValue">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=28248:28294#L933">FormValue</a></h3>
  2468  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) FormValue(key <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2469  				<p>
  2470  FormValue returns the first value for the named component of the query.
  2471  POST and PUT body parameters take precedence over URL query string values.
  2472  FormValue calls ParseMultipartForm and ParseForm if necessary and ignores
  2473  any errors returned by these functions.
  2474  If key is not present, FormValue returns the empty string.
  2475  To access multiple values of the same key, call ParseForm and
  2476  then inspect Request.Form directly.
  2477  </p>
  2478  
  2479  				
  2480  				
  2481  				
  2482  			
  2483  				
  2484  				<h3 id="Request.MultipartReader">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=10760:10822#L292">MultipartReader</a></h3>
  2485  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) MultipartReader() (*<a href="https://golang.org/pkg/mime/multipart/">multipart</a>.<a href="https://golang.org/pkg/mime/multipart/#Reader">Reader</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2486  				<p>
  2487  MultipartReader returns a MIME multipart reader if this is a
  2488  multipart/form-data POST request, else returns nil and an error.
  2489  Use this function instead of ParseMultipartForm to
  2490  process the request body as a stream.
  2491  </p>
  2492  
  2493  				
  2494  				
  2495  				
  2496  			
  2497  				
  2498  				<h3 id="Request.ParseForm">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=26212:26247#L854">ParseForm</a></h3>
  2499  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) ParseForm() <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2500  				<p>
  2501  ParseForm parses the raw query from the URL and updates r.Form.
  2502  </p>
  2503  <p>
  2504  For POST or PUT requests, it also parses the request body as a form and
  2505  put the results into both r.PostForm and r.Form.
  2506  POST and PUT body parameters take precedence over URL query string values
  2507  in r.Form.
  2508  </p>
  2509  <p>
  2510  If the request Body's size has not already been limited by MaxBytesReader,
  2511  the size is capped at 10MB.
  2512  </p>
  2513  <p>
  2514  ParseMultipartForm calls ParseForm automatically.
  2515  It is idempotent.
  2516  </p>
  2517  
  2518  				
  2519  				
  2520  				
  2521  			
  2522  				
  2523  				<h3 id="Request.ParseMultipartForm">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=27267:27326#L895">ParseMultipartForm</a></h3>
  2524  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) ParseMultipartForm(maxMemory <a href="https://golang.org/pkg/builtin/#int64">int64</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2525  				<p>
  2526  ParseMultipartForm parses a request body as multipart/form-data.
  2527  The whole request body is parsed and up to a total of maxMemory bytes of
  2528  its file parts are stored in memory, with the remainder stored on
  2529  disk in temporary files.
  2530  ParseMultipartForm calls ParseForm if necessary.
  2531  After one call to ParseMultipartForm, subsequent calls have no effect.
  2532  </p>
  2533  
  2534  				
  2535  				
  2536  				
  2537  			
  2538  				
  2539  				<h3 id="Request.PostFormValue">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=28755:28805#L948">PostFormValue</a></h3>
  2540  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) PostFormValue(key <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2541  				<p>
  2542  PostFormValue returns the first value for the named component of the POST
  2543  or PUT request body. URL query parameters are ignored.
  2544  PostFormValue calls ParseMultipartForm and ParseForm if necessary and ignores
  2545  any errors returned by these functions.
  2546  If key is not present, PostFormValue returns the empty string.
  2547  </p>
  2548  
  2549  				
  2550  				
  2551  				
  2552  			
  2553  				
  2554  				<h3 id="Request.ProtoAtLeast">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=8370:8423#L228">ProtoAtLeast</a></h3>
  2555  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) ProtoAtLeast(major, minor <a href="https://golang.org/pkg/builtin/#int">int</a>) <a href="https://golang.org/pkg/builtin/#bool">bool</a></pre>
  2556  				<p>
  2557  ProtoAtLeast reports whether the HTTP protocol used
  2558  in the request is at least major.minor.
  2559  </p>
  2560  
  2561  				
  2562  				
  2563  				
  2564  			
  2565  				
  2566  				<h3 id="Request.Referer">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=10131:10165#L276">Referer</a></h3>
  2567  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) Referer() <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2568  				<p>
  2569  Referer returns the referring URL, if sent in the request.
  2570  </p>
  2571  <p>
  2572  Referer is misspelled as in the request itself, a mistake from the
  2573  earliest days of HTTP.  This value can also be fetched from the
  2574  Header map as Header["Referer"]; the benefit of making it available
  2575  as a method is that the compiler can diagnose programs that use the
  2576  alternate (correct English) spelling req.Referrer() but cannot
  2577  diagnose programs that use Header["Referrer"].
  2578  </p>
  2579  
  2580  				
  2581  				
  2582  				
  2583  			
  2584  				
  2585  				<h3 id="Request.SetBasicAuth">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=19455:19512#L604">SetBasicAuth</a></h3>
  2586  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) SetBasicAuth(username, password <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  2587  				<p>
  2588  SetBasicAuth sets the request's Authorization header to use HTTP
  2589  Basic Authentication with the provided username and password.
  2590  </p>
  2591  <p>
  2592  With HTTP Basic Authentication the provided username and password
  2593  are not encrypted.
  2594  </p>
  2595  
  2596  				
  2597  				
  2598  				
  2599  			
  2600  				
  2601  				<h3 id="Request.UserAgent">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=8580:8616#L234">UserAgent</a></h3>
  2602  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) UserAgent() <a href="https://golang.org/pkg/builtin/#string">string</a></pre>
  2603  				<p>
  2604  UserAgent returns the client's User-Agent, if sent in the request.
  2605  </p>
  2606  
  2607  				
  2608  				
  2609  				
  2610  			
  2611  				
  2612  				<h3 id="Request.Write">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=12411:12453#L346">Write</a></h3>
  2613  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) Write(w <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Writer">Writer</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2614  				<p>
  2615  Write writes an HTTP/1.1 request, which is the header and body, in wire format.
  2616  This method consults the following fields of the request:
  2617  </p>
  2618  <pre>Host
  2619  URL
  2620  Method (defaults to "GET")
  2621  Header
  2622  ContentLength
  2623  TransferEncoding
  2624  Body
  2625  </pre>
  2626  <p>
  2627  If Body is present, Content-Length is &lt;= 0 and TransferEncoding
  2628  hasn't been set to "identity", Write adds "Transfer-Encoding:
  2629  chunked" to the header. Body is closed after it is sent.
  2630  </p>
  2631  
  2632  				
  2633  				
  2634  				
  2635  			
  2636  				
  2637  				<h3 id="Request.WriteProxy">func (*Request) <a href="https://golang.org/src/net/http/request.go?s=12846:12893#L356">WriteProxy</a></h3>
  2638  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) WriteProxy(w <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Writer">Writer</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2639  				<p>
  2640  WriteProxy is like Write but writes the request in the form
  2641  expected by an HTTP proxy.  In particular, WriteProxy writes the
  2642  initial Request-URI line of the request with an absolute URI, per
  2643  section 5.1.2 of RFC 2616, including the scheme and host.
  2644  In either case, WriteProxy also writes a Host header, using
  2645  either r.Host or r.URL.Host.
  2646  </p>
  2647  
  2648  				
  2649  				
  2650  				
  2651  			
  2652  		
  2653  			
  2654  			
  2655  			<h2 id="Response">type <a href="https://golang.org/src/net/http/response.go?s=512:2849#L19">Response</a></h2>
  2656  			<pre>type Response struct {
  2657          Status     <a href="https://golang.org/pkg/builtin/#string">string</a> <span class="comment">// e.g. "200 OK"</span>
  2658          StatusCode <a href="https://golang.org/pkg/builtin/#int">int</a>    <span class="comment">// e.g. 200</span>
  2659          Proto      <a href="https://golang.org/pkg/builtin/#string">string</a> <span class="comment">// e.g. "HTTP/1.0"</span>
  2660          ProtoMajor <a href="https://golang.org/pkg/builtin/#int">int</a>    <span class="comment">// e.g. 1</span>
  2661          ProtoMinor <a href="https://golang.org/pkg/builtin/#int">int</a>    <span class="comment">// e.g. 0</span>
  2662  
  2663          <span class="comment">// Header maps header keys to values.  If the response had multiple</span>
  2664          <span class="comment">// headers with the same key, they may be concatenated, with comma</span>
  2665          <span class="comment">// delimiters.  (Section 4.2 of RFC 2616 requires that multiple headers</span>
  2666          <span class="comment">// be semantically equivalent to a comma-delimited sequence.) Values</span>
  2667          <span class="comment">// duplicated by other fields in this struct (e.g., ContentLength) are</span>
  2668          <span class="comment">// omitted from Header.</span>
  2669          <span class="comment">//</span>
  2670          <span class="comment">// Keys in the map are canonicalized (see CanonicalHeaderKey).</span>
  2671          Header <a href="https://golang.org/pkg/net/http/#Header">Header</a>
  2672  
  2673          <span class="comment">// Body represents the response body.</span>
  2674          <span class="comment">//</span>
  2675          <span class="comment">// The http Client and Transport guarantee that Body is always</span>
  2676          <span class="comment">// non-nil, even on responses without a body or responses with</span>
  2677          <span class="comment">// a zero-length body. It is the caller's responsibility to</span>
  2678          <span class="comment">// close Body. The default HTTP client's Transport does not</span>
  2679          <span class="comment">// attempt to reuse HTTP/1.0 or HTTP/1.1 TCP connections</span>
  2680          <span class="comment">// ("keep-alive") unless the Body is read to completion and is</span>
  2681          <span class="comment">// closed.</span>
  2682          <span class="comment">//</span>
  2683          <span class="comment">// The Body is automatically dechunked if the server replied</span>
  2684          <span class="comment">// with a "chunked" Transfer-Encoding.</span>
  2685          Body <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#ReadCloser">ReadCloser</a>
  2686  
  2687          <span class="comment">// ContentLength records the length of the associated content.  The</span>
  2688          <span class="comment">// value -1 indicates that the length is unknown.  Unless Request.Method</span>
  2689          <span class="comment">// is "HEAD", values &gt;= 0 indicate that the given number of bytes may</span>
  2690          <span class="comment">// be read from Body.</span>
  2691          ContentLength <a href="https://golang.org/pkg/builtin/#int64">int64</a>
  2692  
  2693          <span class="comment">// Contains transfer encodings from outer-most to inner-most. Value is</span>
  2694          <span class="comment">// nil, means that "identity" encoding is used.</span>
  2695          TransferEncoding []<a href="https://golang.org/pkg/builtin/#string">string</a>
  2696  
  2697          <span class="comment">// Close records whether the header directed that the connection be</span>
  2698          <span class="comment">// closed after reading Body.  The value is advice for clients: neither</span>
  2699          <span class="comment">// ReadResponse nor Response.Write ever closes a connection.</span>
  2700          Close <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  2701  
  2702          <span class="comment">// Trailer maps trailer keys to values, in the same</span>
  2703          <span class="comment">// format as the header.</span>
  2704          Trailer <a href="https://golang.org/pkg/net/http/#Header">Header</a>
  2705  
  2706          <span class="comment">// The Request that was sent to obtain this Response.</span>
  2707          <span class="comment">// Request's Body is nil (having already been consumed).</span>
  2708          <span class="comment">// This is only populated for Client requests.</span>
  2709          Request *<a href="https://golang.org/pkg/net/http/#Request">Request</a>
  2710  
  2711          <span class="comment">// TLS contains information about the TLS connection on which the</span>
  2712          <span class="comment">// response was received. It is nil for unencrypted responses.</span>
  2713          <span class="comment">// The pointer is shared between responses and should not be</span>
  2714          <span class="comment">// modified.</span>
  2715          TLS *<a href="https://golang.org/pkg/crypto/tls/">tls</a>.<a href="https://golang.org/pkg/crypto/tls/#ConnectionState">ConnectionState</a>
  2716  }</pre>
  2717  			<p>
  2718  Response represents the response from an HTTP request.
  2719  </p>
  2720  
  2721  
  2722  			
  2723  
  2724  			
  2725  
  2726  			
  2727  			
  2728  			
  2729  
  2730  			
  2731  				
  2732  				<h3 id="Get">func <a href="https://golang.org/src/net/http/client.go?s=9198:9246#L270">Get</a></h3>
  2733  				<pre>func Get(url <a href="https://golang.org/pkg/builtin/#string">string</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2734  				<p>
  2735  Get issues a GET to the specified URL. If the response is one of
  2736  the following redirect codes, Get follows the redirect, up to a
  2737  maximum of 10 redirects:
  2738  </p>
  2739  <pre>301 (Moved Permanently)
  2740  302 (Found)
  2741  303 (See Other)
  2742  307 (Temporary Redirect)
  2743  </pre>
  2744  <p>
  2745  An error is returned if there were too many redirects or if there
  2746  was an HTTP protocol error. A non-2xx response doesn't cause an
  2747  error.
  2748  </p>
  2749  <p>
  2750  When err is nil, resp always contains a non-nil resp.Body.
  2751  Caller should close resp.Body when done reading from it.
  2752  </p>
  2753  <p>
  2754  Get is a wrapper around DefaultClient.Get.
  2755  </p>
  2756  <p>
  2757  To make a request with custom headers, use NewRequest and
  2758  DefaultClient.Do.
  2759  </p>
  2760  
  2761  				<div id="example_Get" class="toggle">
  2762  	<div class="collapsed">
  2763  		<p class="exampleHeading toggleButton">▹ <span class="text">Example</span></p>
  2764  	</div>
  2765  	<div class="expanded">
  2766  		<p class="exampleHeading toggleButton">▾ <span class="text">Example</span></p>
  2767  		
  2768  		
  2769  		
  2770  			<div class="play">
  2771  				<div class="input"><textarea class="code">package main
  2772  
  2773  import (
  2774  	"fmt"
  2775  	"io/ioutil"
  2776  	"log"
  2777  	"net/http"
  2778  )
  2779  
  2780  func main() {
  2781  	res, err := http.Get("http://www.google.com/robots.txt")
  2782  	if err != nil {
  2783  		log.Fatal(err)
  2784  	}
  2785  	robots, err := ioutil.ReadAll(res.Body)
  2786  	res.Body.Close()
  2787  	if err != nil {
  2788  		log.Fatal(err)
  2789  	}
  2790  	fmt.Printf("%s", robots)
  2791  }
  2792  </textarea></div>
  2793  				<div class="output"><pre></pre></div>
  2794  				<div class="buttons">
  2795  					<a class="run" title="Run this code [shift-enter]">Run</a>
  2796  					<a class="fmt" title="Format this code">Format</a>
  2797  					
  2798  				</div>
  2799  			</div>
  2800  		
  2801  	</div>
  2802  </div>
  2803  
  2804  				
  2805  			
  2806  				
  2807  				<h3 id="Head">func <a href="https://golang.org/src/net/http/client.go?s=15901:15950#L500">Head</a></h3>
  2808  				<pre>func Head(url <a href="https://golang.org/pkg/builtin/#string">string</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2809  				<p>
  2810  Head issues a HEAD to the specified URL.  If the response is one of
  2811  the following redirect codes, Head follows the redirect, up to a
  2812  maximum of 10 redirects:
  2813  </p>
  2814  <pre>301 (Moved Permanently)
  2815  302 (Found)
  2816  303 (See Other)
  2817  307 (Temporary Redirect)
  2818  </pre>
  2819  <p>
  2820  Head is a wrapper around DefaultClient.Head
  2821  </p>
  2822  
  2823  				
  2824  				
  2825  			
  2826  				
  2827  				<h3 id="Post">func <a href="https://golang.org/src/net/http/client.go?s=13816:13898#L443">Post</a></h3>
  2828  				<pre>func Post(url <a href="https://golang.org/pkg/builtin/#string">string</a>, bodyType <a href="https://golang.org/pkg/builtin/#string">string</a>, body <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Reader">Reader</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2829  				<p>
  2830  Post issues a POST to the specified URL.
  2831  </p>
  2832  <p>
  2833  Caller should close resp.Body when done reading from it.
  2834  </p>
  2835  <p>
  2836  If the provided body is an io.Closer, it is closed after the
  2837  request.
  2838  </p>
  2839  <p>
  2840  Post is a wrapper around DefaultClient.Post.
  2841  </p>
  2842  <p>
  2843  To set custom headers, use NewRequest and DefaultClient.Do.
  2844  </p>
  2845  
  2846  				
  2847  				
  2848  			
  2849  				
  2850  				<h3 id="PostForm">func <a href="https://golang.org/src/net/http/client.go?s=14909:14979#L474">PostForm</a></h3>
  2851  				<pre>func PostForm(url <a href="https://golang.org/pkg/builtin/#string">string</a>, data <a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#Values">Values</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2852  				<p>
  2853  PostForm issues a POST to the specified URL, with data's keys and
  2854  values URL-encoded as the request body.
  2855  </p>
  2856  <p>
  2857  The Content-Type header is set to application/x-www-form-urlencoded.
  2858  To set other headers, use NewRequest and DefaultClient.Do.
  2859  </p>
  2860  <p>
  2861  When err is nil, resp always contains a non-nil resp.Body.
  2862  Caller should close resp.Body when done reading from it.
  2863  </p>
  2864  <p>
  2865  PostForm is a wrapper around DefaultClient.PostForm.
  2866  </p>
  2867  
  2868  				
  2869  				
  2870  			
  2871  				
  2872  				<h3 id="ReadResponse">func <a href="https://golang.org/src/net/http/response.go?s=3992:4059#L111">ReadResponse</a></h3>
  2873  				<pre>func ReadResponse(r *<a href="https://golang.org/pkg/bufio/">bufio</a>.<a href="https://golang.org/pkg/bufio/#Reader">Reader</a>, req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (*<a href="https://golang.org/pkg/net/http/#Response">Response</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2874  				<p>
  2875  ReadResponse reads and returns an HTTP response from r.
  2876  The req parameter optionally specifies the Request that corresponds
  2877  to this Response. If nil, a GET request is assumed.
  2878  Clients must call resp.Body.Close when finished reading resp.Body.
  2879  After that call, clients can inspect resp.Trailer to find key/value
  2880  pairs included in the response trailer.
  2881  </p>
  2882  
  2883  				
  2884  				
  2885  			
  2886  
  2887  			
  2888  				
  2889  				<h3 id="Response.Cookies">func (*Response) <a href="https://golang.org/src/net/http/response.go?s=2924:2962#L82">Cookies</a></h3>
  2890  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Response">Response</a>) Cookies() []*<a href="https://golang.org/pkg/net/http/#Cookie">Cookie</a></pre>
  2891  				<p>
  2892  Cookies parses and returns the cookies set in the Set-Cookie headers.
  2893  </p>
  2894  
  2895  				
  2896  				
  2897  				
  2898  			
  2899  				
  2900  				<h3 id="Response.Location">func (*Response) <a href="https://golang.org/src/net/http/response.go?s=3387:3434#L94">Location</a></h3>
  2901  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Response">Response</a>) Location() (*<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  2902  				<p>
  2903  Location returns the URL of the response's "Location" header,
  2904  if present.  Relative redirects are resolved relative to
  2905  the Response's Request.  ErrNoLocation is returned if no
  2906  Location header is present.
  2907  </p>
  2908  
  2909  				
  2910  				
  2911  				
  2912  			
  2913  				
  2914  				<h3 id="Response.ProtoAtLeast">func (*Response) <a href="https://golang.org/src/net/http/response.go?s=5570:5624#L179">ProtoAtLeast</a></h3>
  2915  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Response">Response</a>) ProtoAtLeast(major, minor <a href="https://golang.org/pkg/builtin/#int">int</a>) <a href="https://golang.org/pkg/builtin/#bool">bool</a></pre>
  2916  				<p>
  2917  ProtoAtLeast reports whether the HTTP protocol used
  2918  in the response is at least major.minor.
  2919  </p>
  2920  
  2921  				
  2922  				
  2923  				
  2924  			
  2925  				
  2926  				<h3 id="Response.Write">func (*Response) <a href="https://golang.org/src/net/http/response.go?s=6162:6205#L200">Write</a></h3>
  2927  				<pre>func (r *<a href="https://golang.org/pkg/net/http/#Response">Response</a>) Write(w <a href="https://golang.org/pkg/io/">io</a>.<a href="https://golang.org/pkg/io/#Writer">Writer</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  2928  				<p>
  2929  Write writes r to w in the HTTP/1.n server response format,
  2930  including the status line, headers, body, and optional trailer.
  2931  </p>
  2932  <p>
  2933  This method consults the following fields of the response r:
  2934  </p>
  2935  <pre>StatusCode
  2936  ProtoMajor
  2937  ProtoMinor
  2938  Request.Method
  2939  TransferEncoding
  2940  Trailer
  2941  Body
  2942  ContentLength
  2943  Header, values for non-canonical keys will have unpredictable behavior
  2944  </pre>
  2945  <p>
  2946  The Response Body is closed after it is sent.
  2947  </p>
  2948  
  2949  				
  2950  				
  2951  				
  2952  			
  2953  		
  2954  			
  2955  			
  2956  			<h2 id="ResponseWriter">type <a href="https://golang.org/src/net/http/server.go?s=1517:2599#L48">ResponseWriter</a></h2>
  2957  			<pre>type ResponseWriter interface {
  2958          <span class="comment">// Header returns the header map that will be sent by</span>
  2959          <span class="comment">// WriteHeader. Changing the header after a call to</span>
  2960          <span class="comment">// WriteHeader (or Write) has no effect unless the modified</span>
  2961          <span class="comment">// headers were declared as trailers by setting the</span>
  2962          <span class="comment">// "Trailer" header before the call to WriteHeader (see example).</span>
  2963          <span class="comment">// To suppress implicit response headers, set their value to nil.</span>
  2964          Header() <a href="https://golang.org/pkg/net/http/#Header">Header</a>
  2965  
  2966          <span class="comment">// Write writes the data to the connection as part of an HTTP reply.</span>
  2967          <span class="comment">// If WriteHeader has not yet been called, Write calls WriteHeader(http.StatusOK)</span>
  2968          <span class="comment">// before writing the data.  If the Header does not contain a</span>
  2969          <span class="comment">// Content-Type line, Write adds a Content-Type set to the result of passing</span>
  2970          <span class="comment">// the initial 512 bytes of written data to DetectContentType.</span>
  2971          Write([]<a href="https://golang.org/pkg/builtin/#byte">byte</a>) (<a href="https://golang.org/pkg/builtin/#int">int</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  2972  
  2973          <span class="comment">// WriteHeader sends an HTTP response header with status code.</span>
  2974          <span class="comment">// If WriteHeader is not called explicitly, the first call to Write</span>
  2975          <span class="comment">// will trigger an implicit WriteHeader(http.StatusOK).</span>
  2976          <span class="comment">// Thus explicit calls to WriteHeader are mainly used to</span>
  2977          <span class="comment">// send error codes.</span>
  2978          WriteHeader(<a href="https://golang.org/pkg/builtin/#int">int</a>)
  2979  }</pre>
  2980  			<p>
  2981  A ResponseWriter interface is used by an HTTP handler to
  2982  construct an HTTP response.
  2983  </p>
  2984  
  2985  
  2986  			
  2987  
  2988  			
  2989  
  2990  			<div id="example_ResponseWriter_trailers" class="toggle">
  2991  	<div class="collapsed">
  2992  		<p class="exampleHeading toggleButton">▹ <span class="text">Example (Trailers)</span></p>
  2993  	</div>
  2994  	<div class="expanded">
  2995  		<p class="exampleHeading toggleButton">▾ <span class="text">Example (Trailers)</span></p>
  2996  		<p>HTTP Trailers are a set of key/value pairs like headers that come
  2997  after the HTTP response, instead of before.
  2998  </p>
  2999  		
  3000  		
  3001  			<div class="play">
  3002  				<div class="input"><textarea class="code">package main
  3003  
  3004  import (
  3005  	"io"
  3006  	"net/http"
  3007  )
  3008  
  3009  func main() {
  3010  	mux := http.NewServeMux()
  3011  	mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
  3012  		// Before any call to WriteHeader or Write, declare
  3013  		// the trailers you will set during the HTTP
  3014  		// response. These three headers are actually sent in
  3015  		// the trailer.
  3016  		w.Header().Set("Trailer", "AtEnd1, AtEnd2")
  3017  		w.Header().Add("Trailer", "AtEnd3")
  3018  
  3019  		w.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
  3020  		w.WriteHeader(http.StatusOK)
  3021  
  3022  		w.Header().Set("AtEnd1", "value 1")
  3023  		io.WriteString(w, "This HTTP response has both headers before this text and trailers at the end.\n")
  3024  		w.Header().Set("AtEnd2", "value 2")
  3025  		w.Header().Set("AtEnd3", "value 3") // These will appear as trailers.
  3026  	})
  3027  }
  3028  </textarea></div>
  3029  				<div class="output"><pre></pre></div>
  3030  				<div class="buttons">
  3031  					<a class="run" title="Run this code [shift-enter]">Run</a>
  3032  					<a class="fmt" title="Format this code">Format</a>
  3033  					
  3034  				</div>
  3035  			</div>
  3036  		
  3037  	</div>
  3038  </div>
  3039  
  3040  			
  3041  			
  3042  
  3043  			
  3044  
  3045  			
  3046  		
  3047  			
  3048  			
  3049  			<h2 id="RoundTripper">type <a href="https://golang.org/src/net/http/client.go?s=2750:3517#L73">RoundTripper</a></h2>
  3050  			<pre>type RoundTripper interface {
  3051          <span class="comment">// RoundTrip executes a single HTTP transaction, returning</span>
  3052          <span class="comment">// the Response for the request req.  RoundTrip should not</span>
  3053          <span class="comment">// attempt to interpret the response.  In particular,</span>
  3054          <span class="comment">// RoundTrip must return err == nil if it obtained a response,</span>
  3055          <span class="comment">// regardless of the response's HTTP status code.  A non-nil</span>
  3056          <span class="comment">// err should be reserved for failure to obtain a response.</span>
  3057          <span class="comment">// Similarly, RoundTrip should not attempt to handle</span>
  3058          <span class="comment">// higher-level protocol details such as redirects,</span>
  3059          <span class="comment">// authentication, or cookies.</span>
  3060          <span class="comment">//</span>
  3061          <span class="comment">// RoundTrip should not modify the request, except for</span>
  3062          <span class="comment">// consuming and closing the Body, including on errors. The</span>
  3063          <span class="comment">// request's URL and Header fields are guaranteed to be</span>
  3064          <span class="comment">// initialized.</span>
  3065          RoundTrip(*<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (*<a href="https://golang.org/pkg/net/http/#Response">Response</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  3066  }</pre>
  3067  			<p>
  3068  RoundTripper is an interface representing the ability to execute a
  3069  single HTTP transaction, obtaining the Response for a given Request.
  3070  </p>
  3071  <p>
  3072  A RoundTripper must be safe for concurrent use by multiple
  3073  goroutines.
  3074  </p>
  3075  
  3076  
  3077  			
  3078  
  3079  			
  3080  				<pre>var <span id="DefaultTransport">DefaultTransport</span> <a href="https://golang.org/pkg/net/http/#RoundTripper">RoundTripper</a> = &amp;<a href="https://golang.org/pkg/net/http/#Transport">Transport</a>{
  3081          <a href="https://golang.org/pkg/net/http/#Proxy">Proxy</a>: <a href="https://golang.org/pkg/net/http/#ProxyFromEnvironment">ProxyFromEnvironment</a>,
  3082          <a href="https://golang.org/pkg/net/http/#Dial">Dial</a>: (&amp;<a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Dialer">Dialer</a>{
  3083                  <a href="https://golang.org/pkg/net/http/#Timeout">Timeout</a>:   30 * <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Second">Second</a>,
  3084                  <a href="https://golang.org/pkg/net/http/#KeepAlive">KeepAlive</a>: 30 * <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Second">Second</a>,
  3085          }).<a href="https://golang.org/pkg/net/http/#Dial">Dial</a>,
  3086          <a href="https://golang.org/pkg/net/http/#TLSHandshakeTimeout">TLSHandshakeTimeout</a>: 10 * <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Second">Second</a>,
  3087  }</pre>
  3088  				<p>
  3089  DefaultTransport is the default implementation of Transport and is
  3090  used by DefaultClient. It establishes network connections as needed
  3091  and caches them for reuse by subsequent calls. It uses HTTP proxies
  3092  as directed by the $HTTP_PROXY and $NO_PROXY (or $http_proxy and
  3093  $no_proxy) environment variables.
  3094  </p>
  3095  
  3096  			
  3097  
  3098  			
  3099  			
  3100  			
  3101  
  3102  			
  3103  				
  3104  				<h3 id="NewFileTransport">func <a href="https://golang.org/src/net/http/filetransport.go?s=827:876#L20">NewFileTransport</a></h3>
  3105  				<pre>func NewFileTransport(fs <a href="https://golang.org/pkg/net/http/#FileSystem">FileSystem</a>) <a href="https://golang.org/pkg/net/http/#RoundTripper">RoundTripper</a></pre>
  3106  				<p>
  3107  NewFileTransport returns a new RoundTripper, serving the provided
  3108  FileSystem. The returned RoundTripper ignores the URL host in its
  3109  incoming requests, as well as most other properties of the
  3110  request.
  3111  </p>
  3112  <p>
  3113  The typical use case for NewFileTransport is to register the "file"
  3114  protocol with a Transport, as in:
  3115  </p>
  3116  <pre>t := &amp;http.Transport{}
  3117  t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
  3118  c := &amp;http.Client{Transport: t}
  3119  res, err := c.Get("file:///etc/passwd")
  3120  ...
  3121  </pre>
  3122  
  3123  				
  3124  				
  3125  			
  3126  
  3127  			
  3128  		
  3129  			
  3130  			
  3131  			<h2 id="ServeMux">type <a href="https://golang.org/src/net/http/server.go?s=46684:46809#L1569">ServeMux</a></h2>
  3132  			<pre>type ServeMux struct {
  3133          <span class="comment">// contains filtered or unexported fields</span>
  3134  }</pre>
  3135  			<p>
  3136  ServeMux is an HTTP request multiplexer.
  3137  It matches the URL of each incoming request against a list of registered
  3138  patterns and calls the handler for the pattern that
  3139  most closely matches the URL.
  3140  </p>
  3141  <p>
  3142  Patterns name fixed, rooted paths, like "/favicon.ico",
  3143  or rooted subtrees, like "/images/" (note the trailing slash).
  3144  Longer patterns take precedence over shorter ones, so that
  3145  if there are handlers registered for both "/images/"
  3146  and "/images/thumbnails/", the latter handler will be
  3147  called for paths beginning "/images/thumbnails/" and the
  3148  former will receive requests for any other paths in the
  3149  "/images/" subtree.
  3150  </p>
  3151  <p>
  3152  Note that since a pattern ending in a slash names a rooted subtree,
  3153  the pattern "/" matches all paths not matched by other registered
  3154  patterns, not just the URL with Path == "/".
  3155  </p>
  3156  <p>
  3157  Patterns may optionally begin with a host name, restricting matches to
  3158  URLs on that host only.  Host-specific patterns take precedence over
  3159  general patterns, so that a handler might register for the two patterns
  3160  "/codesearch" and "codesearch.google.com/" without also taking over
  3161  requests for "<a href="http://www.google.com/">http://www.google.com/</a>".
  3162  </p>
  3163  <p>
  3164  ServeMux also takes care of sanitizing the URL request path,
  3165  redirecting any request containing . or .. elements to an
  3166  equivalent .- and ..-free URL.
  3167  </p>
  3168  
  3169  
  3170  			
  3171  
  3172  			
  3173  
  3174  			
  3175  			
  3176  			
  3177  
  3178  			
  3179  				
  3180  				<h3 id="NewServeMux">func <a href="https://golang.org/src/net/http/server.go?s=46940:46968#L1582">NewServeMux</a></h3>
  3181  				<pre>func NewServeMux() *<a href="https://golang.org/pkg/net/http/#ServeMux">ServeMux</a></pre>
  3182  				<p>
  3183  NewServeMux allocates and returns a new ServeMux.
  3184  </p>
  3185  
  3186  				
  3187  				
  3188  			
  3189  
  3190  			
  3191  				
  3192  				<h3 id="ServeMux.Handle">func (*ServeMux) <a href="https://golang.org/src/net/http/server.go?s=49985:50045#L1694">Handle</a></h3>
  3193  				<pre>func (mux *<a href="https://golang.org/pkg/net/http/#ServeMux">ServeMux</a>) Handle(pattern <a href="https://golang.org/pkg/builtin/#string">string</a>, handler <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>)</pre>
  3194  				<p>
  3195  Handle registers the handler for the given pattern.
  3196  If a handler already exists for pattern, Handle panics.
  3197  </p>
  3198  
  3199  				
  3200  				<div id="example_ServeMux_Handle" class="toggle">
  3201  	<div class="collapsed">
  3202  		<p class="exampleHeading toggleButton">▹ <span class="text">Example</span></p>
  3203  	</div>
  3204  	<div class="expanded">
  3205  		<p class="exampleHeading toggleButton">▾ <span class="text">Example</span></p>
  3206  		
  3207  		
  3208  		
  3209  			<p>Code:</p>
  3210  			<pre class="code">    mux := http.NewServeMux()
  3211      mux.Handle("/api/", apiHandler{})
  3212      mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
  3213              <span class="comment">// The "/" pattern matches everything, so we need to check</span>
  3214              <span class="comment">// that we're at the root here.</span>
  3215              if req.URL.Path != "/" {
  3216                      http.NotFound(w, req)
  3217                      return
  3218              }
  3219              fmt.Fprintf(w, "Welcome to the home page!")
  3220      })
  3221  </pre>
  3222  			
  3223  		
  3224  	</div>
  3225  </div>
  3226  
  3227  				
  3228  			
  3229  				
  3230  				<h3 id="ServeMux.HandleFunc">func (*ServeMux) <a href="https://golang.org/src/net/http/server.go?s=51148:51235#L1733">HandleFunc</a></h3>
  3231  				<pre>func (mux *<a href="https://golang.org/pkg/net/http/#ServeMux">ServeMux</a>) HandleFunc(pattern <a href="https://golang.org/pkg/builtin/#string">string</a>, handler func(<a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, *<a href="https://golang.org/pkg/net/http/#Request">Request</a>))</pre>
  3232  				<p>
  3233  HandleFunc registers the handler function for the given pattern.
  3234  </p>
  3235  
  3236  				
  3237  				
  3238  				
  3239  			
  3240  				
  3241  				<h3 id="ServeMux.Handler">func (*ServeMux) <a href="https://golang.org/src/net/http/server.go?s=48689:48757#L1646">Handler</a></h3>
  3242  				<pre>func (mux *<a href="https://golang.org/pkg/net/http/#ServeMux">ServeMux</a>) Handler(r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (h <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>, pattern <a href="https://golang.org/pkg/builtin/#string">string</a>)</pre>
  3243  				<p>
  3244  Handler returns the handler to use for the given request,
  3245  consulting r.Method, r.Host, and r.URL.Path. It always returns
  3246  a non-nil handler. If the path is not in its canonical form, the
  3247  handler will be an internally-generated handler that redirects
  3248  to the canonical path.
  3249  </p>
  3250  <p>
  3251  Handler also returns the registered pattern that matches the
  3252  request or, in the case of internally-generated redirects,
  3253  the pattern that will match after following the redirect.
  3254  </p>
  3255  <p>
  3256  If there is no registered handler that applies to the request,
  3257  Handler returns a “page not found” handler and an empty pattern.
  3258  </p>
  3259  
  3260  				
  3261  				
  3262  				
  3263  			
  3264  				
  3265  				<h3 id="ServeMux.ServeHTTP">func (*ServeMux) <a href="https://golang.org/src/net/http/server.go?s=49617:49677#L1680">ServeHTTP</a></h3>
  3266  				<pre>func (mux *<a href="https://golang.org/pkg/net/http/#ServeMux">ServeMux</a>) ServeHTTP(w <a href="https://golang.org/pkg/net/http/#ResponseWriter">ResponseWriter</a>, r *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)</pre>
  3267  				<p>
  3268  ServeHTTP dispatches the request to the handler whose
  3269  pattern most closely matches the request URL.
  3270  </p>
  3271  
  3272  				
  3273  				
  3274  				
  3275  			
  3276  		
  3277  			
  3278  			
  3279  			<h2 id="Server">type <a href="https://golang.org/src/net/http/server.go?s=52296:53789#L1760">Server</a></h2>
  3280  			<pre>type Server struct {
  3281          Addr           <a href="https://golang.org/pkg/builtin/#string">string</a>        <span class="comment">// TCP address to listen on, ":http" if empty</span>
  3282          Handler        <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>       <span class="comment">// handler to invoke, http.DefaultServeMux if nil</span>
  3283          ReadTimeout    <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a> <span class="comment">// maximum duration before timing out read of the request</span>
  3284          WriteTimeout   <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a> <span class="comment">// maximum duration before timing out write of the response</span>
  3285          MaxHeaderBytes <a href="https://golang.org/pkg/builtin/#int">int</a>           <span class="comment">// maximum size of request headers, DefaultMaxHeaderBytes if 0</span>
  3286          TLSConfig      *<a href="https://golang.org/pkg/crypto/tls/">tls</a>.<a href="https://golang.org/pkg/crypto/tls/#Config">Config</a>   <span class="comment">// optional TLS config, used by ListenAndServeTLS</span>
  3287  
  3288          <span class="comment">// TLSNextProto optionally specifies a function to take over</span>
  3289          <span class="comment">// ownership of the provided TLS connection when an NPN</span>
  3290          <span class="comment">// protocol upgrade has occurred.  The map key is the protocol</span>
  3291          <span class="comment">// name negotiated. The Handler argument should be used to</span>
  3292          <span class="comment">// handle HTTP requests and will initialize the Request's TLS</span>
  3293          <span class="comment">// and RemoteAddr if not already set.  The connection is</span>
  3294          <span class="comment">// automatically closed when the function returns.</span>
  3295          TLSNextProto map[<a href="https://golang.org/pkg/builtin/#string">string</a>]func(*<a href="https://golang.org/pkg/net/http/#Server">Server</a>, *<a href="https://golang.org/pkg/crypto/tls/">tls</a>.<a href="https://golang.org/pkg/crypto/tls/#Conn">Conn</a>, <a href="https://golang.org/pkg/net/http/#Handler">Handler</a>)
  3296  
  3297          <span class="comment">// ConnState specifies an optional callback function that is</span>
  3298          <span class="comment">// called when a client connection changes state. See the</span>
  3299          <span class="comment">// ConnState type and associated constants for details.</span>
  3300          ConnState func(<a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Conn">Conn</a>, <a href="https://golang.org/pkg/net/http/#ConnState">ConnState</a>)
  3301  
  3302          <span class="comment">// ErrorLog specifies an optional logger for errors accepting</span>
  3303          <span class="comment">// connections and unexpected behavior from handlers.</span>
  3304          <span class="comment">// If nil, logging goes to os.Stderr via the log package's</span>
  3305          <span class="comment">// standard logger.</span>
  3306          ErrorLog *<a href="https://golang.org/pkg/log/">log</a>.<a href="https://golang.org/pkg/log/#Logger">Logger</a>
  3307          <span class="comment">// contains filtered or unexported fields</span>
  3308  }</pre>
  3309  			<p>
  3310  A Server defines parameters for running an HTTP server.
  3311  The zero value for Server is a valid configuration.
  3312  </p>
  3313  
  3314  
  3315  			
  3316  
  3317  			
  3318  
  3319  			
  3320  			
  3321  			
  3322  
  3323  			
  3324  
  3325  			
  3326  				
  3327  				<h3 id="Server.ListenAndServe">func (*Server) <a href="https://golang.org/src/net/http/server.go?s=55886:55927#L1858">ListenAndServe</a></h3>
  3328  				<pre>func (srv *<a href="https://golang.org/pkg/net/http/#Server">Server</a>) ListenAndServe() <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  3329  				<p>
  3330  ListenAndServe listens on the TCP network address srv.Addr and then
  3331  calls Serve to handle requests on incoming connections.  If
  3332  srv.Addr is blank, ":http" is used.
  3333  </p>
  3334  
  3335  				
  3336  				
  3337  				
  3338  			
  3339  				
  3340  				<h3 id="Server.ListenAndServeTLS">func (*Server) <a href="https://golang.org/src/net/http/server.go?s=60146:60214#L2003">ListenAndServeTLS</a></h3>
  3341  				<pre>func (srv *<a href="https://golang.org/pkg/net/http/#Server">Server</a>) ListenAndServeTLS(certFile, keyFile <a href="https://golang.org/pkg/builtin/#string">string</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  3342  				<p>
  3343  ListenAndServeTLS listens on the TCP network address srv.Addr and
  3344  then calls Serve to handle requests on incoming TLS connections.
  3345  </p>
  3346  <p>
  3347  Filenames containing a certificate and matching private key for the
  3348  server must be provided if the Server's TLSConfig.Certificates is
  3349  not populated. If the certificate is signed by a certificate
  3350  authority, the certFile should be the concatenation of the server's
  3351  certificate, any intermediates, and the CA's certificate.
  3352  </p>
  3353  <p>
  3354  If srv.Addr is blank, ":https" is used.
  3355  </p>
  3356  
  3357  				
  3358  				
  3359  				
  3360  			
  3361  				
  3362  				<h3 id="Server.Serve">func (*Server) <a href="https://golang.org/src/net/http/server.go?s=56308:56354#L1873">Serve</a></h3>
  3363  				<pre>func (srv *<a href="https://golang.org/pkg/net/http/#Server">Server</a>) Serve(l <a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Listener">Listener</a>) <a href="https://golang.org/pkg/builtin/#error">error</a></pre>
  3364  				<p>
  3365  Serve accepts incoming connections on the Listener l, creating a
  3366  new service goroutine for each.  The service goroutines read requests and
  3367  then call srv.Handler to reply to them.
  3368  </p>
  3369  
  3370  				
  3371  				
  3372  				
  3373  			
  3374  				
  3375  				<h3 id="Server.SetKeepAlivesEnabled">func (*Server) <a href="https://golang.org/src/net/http/server.go?s=57329:57376#L1912">SetKeepAlivesEnabled</a></h3>
  3376  				<pre>func (srv *<a href="https://golang.org/pkg/net/http/#Server">Server</a>) SetKeepAlivesEnabled(v <a href="https://golang.org/pkg/builtin/#bool">bool</a>)</pre>
  3377  				<p>
  3378  SetKeepAlivesEnabled controls whether HTTP keep-alives are enabled.
  3379  By default, keep-alives are always enabled. Only very
  3380  resource-constrained environments or servers in the process of
  3381  shutting down should disable them.
  3382  </p>
  3383  
  3384  				
  3385  				
  3386  				
  3387  			
  3388  		
  3389  			
  3390  			
  3391  			<h2 id="Transport">type <a href="https://golang.org/src/net/http/transport.go?s=1324:4038#L39">Transport</a></h2>
  3392  			<pre>type Transport struct {
  3393  
  3394          <span class="comment">// Proxy specifies a function to return a proxy for a given</span>
  3395          <span class="comment">// Request. If the function returns a non-nil error, the</span>
  3396          <span class="comment">// request is aborted with the provided error.</span>
  3397          <span class="comment">// If Proxy is nil or returns a nil *URL, no proxy is used.</span>
  3398          Proxy func(*<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (*<a href="https://golang.org/pkg/net/url/">url</a>.<a href="https://golang.org/pkg/net/url/#URL">URL</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  3399  
  3400          <span class="comment">// Dial specifies the dial function for creating unencrypted</span>
  3401          <span class="comment">// TCP connections.</span>
  3402          <span class="comment">// If Dial is nil, net.Dial is used.</span>
  3403          Dial func(network, addr <a href="https://golang.org/pkg/builtin/#string">string</a>) (<a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Conn">Conn</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  3404  
  3405          <span class="comment">// DialTLS specifies an optional dial function for creating</span>
  3406          <span class="comment">// TLS connections for non-proxied HTTPS requests.</span>
  3407          <span class="comment">//</span>
  3408          <span class="comment">// If DialTLS is nil, Dial and TLSClientConfig are used.</span>
  3409          <span class="comment">//</span>
  3410          <span class="comment">// If DialTLS is set, the Dial hook is not used for HTTPS</span>
  3411          <span class="comment">// requests and the TLSClientConfig and TLSHandshakeTimeout</span>
  3412          <span class="comment">// are ignored. The returned net.Conn is assumed to already be</span>
  3413          <span class="comment">// past the TLS handshake.</span>
  3414          DialTLS func(network, addr <a href="https://golang.org/pkg/builtin/#string">string</a>) (<a href="https://golang.org/pkg/net/">net</a>.<a href="https://golang.org/pkg/net/#Conn">Conn</a>, <a href="https://golang.org/pkg/builtin/#error">error</a>)
  3415  
  3416          <span class="comment">// TLSClientConfig specifies the TLS configuration to use with</span>
  3417          <span class="comment">// tls.Client. If nil, the default configuration is used.</span>
  3418          TLSClientConfig *<a href="https://golang.org/pkg/crypto/tls/">tls</a>.<a href="https://golang.org/pkg/crypto/tls/#Config">Config</a>
  3419  
  3420          <span class="comment">// TLSHandshakeTimeout specifies the maximum amount of time waiting to</span>
  3421          <span class="comment">// wait for a TLS handshake. Zero means no timeout.</span>
  3422          TLSHandshakeTimeout <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a>
  3423  
  3424          <span class="comment">// DisableKeepAlives, if true, prevents re-use of TCP connections</span>
  3425          <span class="comment">// between different HTTP requests.</span>
  3426          DisableKeepAlives <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  3427  
  3428          <span class="comment">// DisableCompression, if true, prevents the Transport from</span>
  3429          <span class="comment">// requesting compression with an "Accept-Encoding: gzip"</span>
  3430          <span class="comment">// request header when the Request contains no existing</span>
  3431          <span class="comment">// Accept-Encoding value. If the Transport requests gzip on</span>
  3432          <span class="comment">// its own and gets a gzipped response, it's transparently</span>
  3433          <span class="comment">// decoded in the Response.Body. However, if the user</span>
  3434          <span class="comment">// explicitly requested gzip it is not automatically</span>
  3435          <span class="comment">// uncompressed.</span>
  3436          DisableCompression <a href="https://golang.org/pkg/builtin/#bool">bool</a>
  3437  
  3438          <span class="comment">// MaxIdleConnsPerHost, if non-zero, controls the maximum idle</span>
  3439          <span class="comment">// (keep-alive) to keep per-host.  If zero,</span>
  3440          <span class="comment">// DefaultMaxIdleConnsPerHost is used.</span>
  3441          MaxIdleConnsPerHost <a href="https://golang.org/pkg/builtin/#int">int</a>
  3442  
  3443          <span class="comment">// ResponseHeaderTimeout, if non-zero, specifies the amount of</span>
  3444          <span class="comment">// time to wait for a server's response headers after fully</span>
  3445          <span class="comment">// writing the request (including its body, if any). This</span>
  3446          <span class="comment">// time does not include the time to read the response body.</span>
  3447          ResponseHeaderTimeout <a href="https://golang.org/pkg/time/">time</a>.<a href="https://golang.org/pkg/time/#Duration">Duration</a>
  3448          <span class="comment">// contains filtered or unexported fields</span>
  3449  }</pre>
  3450  			<p>
  3451  Transport is an implementation of RoundTripper that supports HTTP,
  3452  HTTPS, and HTTP proxies (for either HTTP or HTTPS with CONNECT).
  3453  Transport can also cache connections for future re-use.
  3454  </p>
  3455  
  3456  
  3457  			
  3458  
  3459  			
  3460  
  3461  			
  3462  			
  3463  			
  3464  
  3465  			
  3466  
  3467  			
  3468  				
  3469  				<h3 id="Transport.CancelRequest">func (*Transport) <a href="https://golang.org/src/net/http/transport.go?s=8881:8928#L269">CancelRequest</a></h3>
  3470  				<pre>func (t *<a href="https://golang.org/pkg/net/http/#Transport">Transport</a>) CancelRequest(req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>)</pre>
  3471  				<p>
  3472  CancelRequest cancels an in-flight request by closing its connection.
  3473  CancelRequest should only be called after RoundTrip has returned.
  3474  </p>
  3475  
  3476  				
  3477  				
  3478  				
  3479  			
  3480  				
  3481  				<h3 id="Transport.CloseIdleConnections">func (*Transport) <a href="https://golang.org/src/net/http/transport.go?s=8498:8540#L253">CloseIdleConnections</a></h3>
  3482  				<pre>func (t *<a href="https://golang.org/pkg/net/http/#Transport">Transport</a>) CloseIdleConnections()</pre>
  3483  				<p>
  3484  CloseIdleConnections closes any connections which were previously
  3485  connected from previous requests but are now sitting idle in
  3486  a "keep-alive" state. It does not interrupt any connections currently
  3487  in use.
  3488  </p>
  3489  
  3490  				
  3491  				
  3492  				
  3493  			
  3494  				
  3495  				<h3 id="Transport.RegisterProtocol">func (*Transport) <a href="https://golang.org/src/net/http/transport.go?s=7866:7934#L234">RegisterProtocol</a></h3>
  3496  				<pre>func (t *<a href="https://golang.org/pkg/net/http/#Transport">Transport</a>) RegisterProtocol(scheme <a href="https://golang.org/pkg/builtin/#string">string</a>, rt <a href="https://golang.org/pkg/net/http/#RoundTripper">RoundTripper</a>)</pre>
  3497  				<p>
  3498  RegisterProtocol registers a new protocol with scheme.
  3499  The Transport will pass requests using the given scheme to rt.
  3500  It is rt's responsibility to simulate HTTP request semantics.
  3501  </p>
  3502  <p>
  3503  RegisterProtocol can be used by other packages to provide
  3504  implementations of protocol schemes like "ftp" or "file".
  3505  </p>
  3506  
  3507  				
  3508  				
  3509  				
  3510  			
  3511  				
  3512  				<h3 id="Transport.RoundTrip">func (*Transport) <a href="https://golang.org/src/net/http/transport.go?s=6344:6415#L181">RoundTrip</a></h3>
  3513  				<pre>func (t *<a href="https://golang.org/pkg/net/http/#Transport">Transport</a>) RoundTrip(req *<a href="https://golang.org/pkg/net/http/#Request">Request</a>) (resp *<a href="https://golang.org/pkg/net/http/#Response">Response</a>, err <a href="https://golang.org/pkg/builtin/#error">error</a>)</pre>
  3514  				<p>
  3515  RoundTrip implements the RoundTripper interface.
  3516  </p>
  3517  <p>
  3518  For higher-level HTTP client support (such as handling of cookies
  3519  and redirects), see Get, Post, and the Client type.
  3520  </p>
  3521  
  3522  				
  3523  				
  3524  				
  3525  			
  3526  		
  3527  	
  3528  
  3529  	
  3530  
  3531  
  3532  
  3533  
  3534  
  3535  	
  3536  	
  3537  		<h2 id="pkg-subdirectories">Subdirectories</h2>
  3538  	
  3539  	
  3540  
  3541  
  3542  	<div class="pkg-dir">
  3543  		<table>
  3544  			<tbody><tr>
  3545  				<th class="pkg-name">Name</th>
  3546  				<th class="pkg-synopsis">Synopsis</th>
  3547  			</tr>
  3548  
  3549  			
  3550  			<tr>
  3551  				<td colspan="2"><a href="https://golang.org/pkg/net/">..</a></td>
  3552  			</tr>
  3553  			
  3554  
  3555  			
  3556  				
  3557  					<tr>
  3558  						<td class="pkg-name" style="padding-left: 0px;">
  3559  							<a href="https://golang.org/pkg/net/http/cgi/">cgi</a>
  3560  						</td>
  3561  						<td class="pkg-synopsis">
  3562  							Package cgi implements CGI (Common Gateway Interface) as specified in RFC 3875.
  3563  						</td>
  3564  					</tr>
  3565  				
  3566  			
  3567  				
  3568  					<tr>
  3569  						<td class="pkg-name" style="padding-left: 0px;">
  3570  							<a href="https://golang.org/pkg/net/http/cookiejar/">cookiejar</a>
  3571  						</td>
  3572  						<td class="pkg-synopsis">
  3573  							Package cookiejar implements an in-memory RFC 6265-compliant http.CookieJar.
  3574  						</td>
  3575  					</tr>
  3576  				
  3577  			
  3578  				
  3579  					<tr>
  3580  						<td class="pkg-name" style="padding-left: 0px;">
  3581  							<a href="https://golang.org/pkg/net/http/fcgi/">fcgi</a>
  3582  						</td>
  3583  						<td class="pkg-synopsis">
  3584  							Package fcgi implements the FastCGI protocol.
  3585  						</td>
  3586  					</tr>
  3587  				
  3588  			
  3589  				
  3590  					<tr>
  3591  						<td class="pkg-name" style="padding-left: 0px;">
  3592  							<a href="https://golang.org/pkg/net/http/httptest/">httptest</a>
  3593  						</td>
  3594  						<td class="pkg-synopsis">
  3595  							Package httptest provides utilities for HTTP testing.
  3596  						</td>
  3597  					</tr>
  3598  				
  3599  			
  3600  				
  3601  					<tr>
  3602  						<td class="pkg-name" style="padding-left: 0px;">
  3603  							<a href="https://golang.org/pkg/net/http/httputil/">httputil</a>
  3604  						</td>
  3605  						<td class="pkg-synopsis">
  3606  							Package httputil provides HTTP utility functions, complementing the more common ones in the net/http package.
  3607  						</td>
  3608  					</tr>
  3609  				
  3610  			
  3611  				
  3612  					<tr>
  3613  						<td class="pkg-name" style="padding-left: 0px;">
  3614  							<a href="https://golang.org/pkg/net/http/pprof/">pprof</a>
  3615  						</td>
  3616  						<td class="pkg-synopsis">
  3617  							Package pprof serves via its HTTP server runtime profiling data in the format expected by the pprof visualization tool.
  3618  						</td>
  3619  					</tr>
  3620  				
  3621  			
  3622  		</tbody></table>
  3623  	</div>
  3624  
  3625  
  3626  	
  3627  
  3628  
  3629  
  3630  <div id="footer">
  3631  Build version go1.5.1.<br>
  3632  Except as <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
  3633  the content of this page is licensed under the
  3634  Creative Commons Attribution 3.0 License,
  3635  and code is licensed under a <a href="https://golang.org/LICENSE">BSD license</a>.<br>
  3636  <a href="https://golang.org/doc/tos.html">Terms of Service</a> | 
  3637  <a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
  3638  </div>
  3639  
  3640  </div><!-- .container -->
  3641  </div><!-- #page -->
  3642  
  3643  <!-- TODO(adonovan): load these from <head> using "defer" attribute? -->
  3644  <script type="text/javascript" src="./http - The Go Programming Language_files/jquery.min.js"></script>
  3645  <script type="text/javascript" src="./http - The Go Programming Language_files/jquery.treeview.js"></script>
  3646  <script type="text/javascript" src="./http - The Go Programming Language_files/jquery.treeview.edit.js"></script>
  3647  
  3648  
  3649  <script type="text/javascript" src="./http - The Go Programming Language_files/playground.js"></script>
  3650  
  3651  <script type="text/javascript" src="./http - The Go Programming Language_files/godocs.js"></script>
  3652  
  3653  <script type="text/javascript">
  3654  (function() {
  3655    var ga = document.createElement("script"); ga.type = "text/javascript"; ga.async = true;
  3656    ga.src = ("https:" == document.location.protocol ? "https://ssl" : "http://www") + ".google-analytics.com/ga.js";
  3657    var s = document.getElementsByTagName("script")[0]; s.parentNode.insertBefore(ga, s);
  3658  })();
  3659  </script>
  3660  
  3661  
  3662  
  3663  </body></html>